erbside 0.1.0

data/lib/erbside/metadata.rb

@@ -0,0 +1,122 @@
+module Erbside
+
+  # Metadata belongs to the project being scaffold.
+  #
+  # TODO: Support POM::Metadata
+  #
+  class Metadata
+
+    #require 'facets/ostruct'
+
+    begin
+      require 'pom'
+    rescue LoadError
+    end
+
+    # Project root pathname.
+    attr :root
+
+    #
+    def initialize(root=nil)
+      @root = self.class.root(root) || Dir.pwd
+
+      if defined?(POM)
+        @pom  = POM::Metadata.new(@root)
+      else
+        @pom  = nil
+      end
+
+      @cache  = {} #OpenStruct.new
+
+      load_metadata  # TODO: when pom supports arbitrary metadata, merge @pom and @cache into same variable.
+    end
+
+    #
+    def method_missing(s, *a)
+      return super unless a.empty?
+      if @pom
+        begin
+          @pom.__send__(s, *a)
+        rescue
+          @cache.key?(s.to_s) ? @cache[s.to_s] : nil
+        end
+      else
+        @cache.key?(s.to_s) ? @cache[s.to_s] : nil
+      end
+    end
+
+    # Provide metadata to hash. Some (stencil) template systems
+    # need the data in hash form.
+
+    def to_h
+      if @pom
+        @pom.to_h
+      else
+        @cache
+      end
+    end
+
+  private
+
+    # Load metadata. This serves as the fallback if POM is not used.
+
+    def load_metadata
+      Dir[File.join(metadir, '*')].each do |f|
+        val = File.read(f).strip
+        val = YAML.load(val) if val =~ /\A---/
+        @cache[File.basename(f)] = val
+      end
+    end
+
+    # What is project root's metadirectory?
+
+    def metadir
+      @metadir ||= Dir[File.join(root, '{.meta,meta}/')].first || '.meta/'
+    end
+
+    #def load_value(name)
+    #  file = File.join(metadir, name)
+    #  file = Dir[file].first
+    #  if file && File.file?(file)
+    #    #return erb(file).strip
+    #    return File.read(file).strip
+    #  end
+    #end
+
+    # Root directory is indicated by the presence of a +meta/+ directory,
+    # or +.meta/+ hidden directory.
+
+    ROOT_INDICATORS = [ '{.meta,meta}/' ]
+
+    # Locate the project's root directory. This is determined
+    # by ascending up the directory tree from the current position
+    # until the ROOT_INDICATORS is matched. Returns +nil+ if not found.
+
+    def self.root(local=Dir.pwd)
+      local ||= Dir.pwd
+      Dir.chdir(local) do
+        dir = nil
+        ROOT_INDICATORS.find do |i|
+          dir = locate_root_at(i)
+        end
+        dir ? Pathname.new(File.dirname(dir)) : nil
+      end
+    end
+
+    #
+    def self.locate_root_at(indicator)
+      root = nil
+      dir  = Dir.pwd
+      while !root && dir != '/'
+        find = File.join(dir, indicator)
+        root = Dir.glob(find, File::FNM_CASEFOLD).first
+        #break if root
+        dir = File.dirname(dir)
+      end
+      root ? Pathname.new(root) : nil
+    end
+
+  end
+
+end
+

data/lib/erbside/runner.rb

@@ -0,0 +1,128 @@
+module Erbside
+
+  # = Runner
+  #
+  class Runner
+
+    require 'erbside/inline'
+    require 'erbside/metadata'
+
+    require 'facets/kernel/ask'
+    require 'facets/string/tabto'
+
+
+    # A T T R I B U T E S
+
+    attr_accessor :files
+
+    attr_accessor :force
+
+    attr_accessor :skip
+
+    # The +output+ can be any object that responds to #<<.
+    attr_accessor :output
+
+    #attr_accessor :delete
+
+
+    # I N I T I A L I Z E
+
+    #
+    def initialize(files, options)
+      files = files || Dir["**/*#{ext_glob}"]
+      files = files.map do |file|
+        if File.directory?(file)
+          collect_usable_files(file)
+        else
+          file
+        end
+      end.flatten
+      @files  = files
+
+      @force  = options[:force]
+      @skip   = options[:skip]
+      @output = options[:output]
+      #@delete = options[:delete]
+    end
+
+    #
+    def collect_usable_files(dir)
+      Dir[File.join(dir,"**/*#{ext_glob}")]
+    end
+
+    #def delete? ; @delete ; end
+    def force?  ; @force  ; end
+    def skip?   ; @skip   ; end
+
+    def debug?  ; $DEBUG  ; end
+    def trial?  ; $TRIAL  ; end
+
+    #
+    def render
+      files.each do |file|
+        render_file(file)
+      end
+    end
+
+    # Search through a file for inline templates, render and output.
+    def render_file(file)
+      parser = Inline.factory(file)
+
+      if !parser
+        puts "  unrecognized #{file}" if $DEBUG || $TRIAL
+        return
+      end
+
+      template = parser.new(file)
+
+      if template.exist? && skip?
+        puts "  #{template.relative_output} skipped"
+      else
+        result = template.render
+        if output
+          output << (result + "\n")
+        else
+          save(template, result)
+        end
+      end
+    end
+
+    #
+    def save(template, result)
+      name = template.relative_output
+      save = false
+      if trial?
+        puts "  #{name}"
+      else
+        if template.exist?
+          if !template.changed?
+            puts "  unchanged #{name}"
+          elsif !force?
+            case ask("  overwrite #{name}? ")
+            when 'y', 'yes'
+              save = true
+            end
+          else
+            save = true
+          end
+        else
+          save = true
+        end
+      end
+      if save
+        template.save
+        puts "    written #{name}"
+      end
+    end
+
+
+    private
+
+    #
+    def ext_glob
+      '{' + Inline.extension_list.join(',') + '}'
+    end
+
+  end
+
+end

data/lib/plugins/syckle/erbside.rb

@@ -0,0 +1,45 @@
+module Syckle::Plugins
+
+  # = Erbside Generation
+  #
+  class Erbside < Service
+
+    cycle :main, :generate
+    cycle :site, :generate
+
+    # Make automatic?
+    #autorun do
+    #  ...
+    #end
+
+    available do |project|
+      begin
+        require 'erbside'
+        true
+      rescue LoadError
+        false
+      end
+    end
+
+    #
+    #def safe?; @safe; end
+
+    #
+    def generate(options={})
+      options ||= {}
+
+      dir = nil # defaults to curent directory
+
+      options[:trial]  = trial?
+      options[:debug] = debug?
+      options[:quiet] = quiet?
+      options[:force] = force?
+
+      tiller = Erbside::Runner.new(dir, options)
+      tiller.till
+    end
+
+  end
+
+end
+

data/test/functional/applique/env.rb

@@ -0,0 +1,33 @@
+#require 'tmpdir'
+require 'erbside'
+
+When "Given a file named '(((.*?)))'" do |name, text|
+  File.open(name, 'w+'){ |f| f << text }
+end
+
+When "Rendering via the commandline" do |text|
+  #@result = Erbside.cli('-o', 'example.rb')
+  text.sub!(/^\$\s*/, '')
+  @result = `#{text}`
+end
+
+When "result will be" do |text|
+  text.strip.assert == @result.strip
+end
+
+When "The rendered result of '(((.*?)))' will be" do |file, text|
+  result = ""
+  runner  = Erbside::Runner.new([file], :output=>result)
+  runner.render
+
+  text.strip.assert == result.strip
+end
+
+
+#    out = File.join(@tmpdir, "fixture/inline.rb")
+#    system "till -f #{out}"
+#    expect = File.read('test/features/proofs/inline.rb')
+#  result = File.read(out)
+#
+#   assert_equal(expect, result)
+

data/test/functional/bash.rdoc

@@ -0,0 +1,57 @@
+== Bash
+
+=== Sideline Rendering
+
+Given a file named 'example.sh' containing:
+
+  # ordinary comment
+  VERSION = "?"  # :erb: VERSION = "<%= 1+1 %>"
+
+The rendered result of 'example.sh' will be:
+
+  # ordinary comment
+  VERSION = "2"  # :erb: VERSION = "<%= 1+1 %>"
+
+=== Sideline Rendering with First Match Marker
+
+Given a file named 'example.sh' containing:
+
+  # Script generated 200X  #:erb: ^generated <%= 2009 %>
+
+The rendered result of 'example.sh' will be:
+
+  # Script generated 2009  #:erb: ^generated <%= 2009 %>
+
+Notice in this case we rendered a comment.
+
+=== Multiline Rendering
+
+Given a file named 'example.sh' containing:
+
+  #:erb+1: <%= %w{z y x}.sort.join("\n") %>
+  blah blah blah
+
+The rendered result of 'example.sh' will be:
+
+  #:erb+3: <%= %w{z y x}.sort.join("\n") %>
+  x
+  y
+  z
+
+=== Block Rendering
+
+Given a file named 'example.sh' containing:
+
+  #=begin :erb+0:
+  <%= %w{a b c}.map{ |x| "#{x}!" }.join("\n") %>
+  #=end
+
+The rendered result of 'example.sh' will be:
+
+  #=begin :erb+3:
+  <%= %w{a b c}.map{ |x| "#{x}!" }.join("\n") %>
+  #=end
+  a!
+  b!
+  c!
+

data/test/functional/cli.rdoc

@@ -0,0 +1,14 @@
+== Commandline Interface
+
+Given a file named 'example.rb' containing:
+
+  example # :erb: change <%= 1+1 %>
+
+Rendering via the commandline:
+
+  $ erbside -o example.rb
+
+The result will be:
+
+  change 2 # :erb: change <%= 1+1 %>
+

data/test/functional/cpp.rdoc

@@ -0,0 +1,50 @@
+== C/C++
+
+=== Sideline Example
+
+Sideline example, where the erb comment is to the side of the
+text it will replace. Given a file named 'example.c' containing:
+
+  version = "?"; // :erb: version = "<%= 1+1 %>";
+
+The rendered result of 'example.c' will be:
+
+  version = "2"; // :erb: version = "<%= 1+1 %>";
+
+=== Multiline Example
+
+Multi-line example, where the erb comment replaces multiple lines but
+is defined by a single line. Given a file named 'example.c' containing:
+
+  void main() {
+    //:erb+1: <%= %w{z(); y(); x();}.sort.join("\n").indent(2) %>
+    will be replaced
+  }
+
+The rendered result of 'example.c' will be:
+
+  void main() {
+    //:erb+3: <%= %w{z(); y(); x();}.sort.join("\n").indent(2) %>
+    x();
+    y();
+    z();
+  }
+
+=== Block Example
+
+Block example, where the ERB comment replaces multiple lines and is
+defined by a block comment. Given a file named 'example.c' containing:
+
+  /* :erb+0:
+  <%= %w{a b c}.map{ |e| "\#include <#{e}.h>" }.join("\n") %>
+  */
+
+The rendered result of 'example.c' will be:
+
+  /* :erb+3:
+  <%= %w{a b c}.map{ |e| "\#include <#{e}.h>" }.join("\n") %>
+  */
+  #include <a.h>
+  #include <b.h>
+  #include <c.h>
+