devver-germinate 1.0.0

data/lib/germinate.rb

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'fattr'
+require 'logger'
+
+module Germinate
+
+  # :stopdoc:
+  VERSION = '1.0.0'
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  # :startdoc:
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    VERSION
+  end
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    args.empty? ? PATH : ::File.join(PATH, args.flatten)
+  end
+
+  # Utility method used to require all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= ::File.basename(fname, '.*')
+    search_me = ::File.expand_path(
+        ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+
+    Dir.glob(search_me).sort.each {|rb| require rb}
+  end
+
+  Fattr(:logger) { Logger.new($stderr) }
+
+end  # module Germinate
+
+Germinate.require_all_libs_relative_to(__FILE__)
+
+# EOF

data/lib/germinate/application.rb

@@ -0,0 +1,62 @@
+# The Application ties all the other componts together.  It has public methods
+# roughly corresponding commands that the 'germ' command-line tool supports.
+class Germinate::Application
+  attr_writer :formatter
+
+  def format(source, output=$stdout, errors=$stderr)
+    librarian = load_librarian(source)
+    editor    = Germinate::ArticleEditor.new(librarian)
+    formatter = Germinate::ArticleFormatter.new(output)
+
+    Germinate::SharedStyleAttributes.fattrs.each do 
+      |style_attribute|
+      formatter.send(style_attribute, librarian.send(style_attribute))
+    end
+    formatter.start!
+    editor.each_hunk do |hunk|
+      formatter.format!(hunk)
+    end
+    formatter.finish!
+  end
+
+  def list(source, things_to_list, output=$stdout)
+    librarian = load_librarian(source)
+    if things_to_list.include?(:sections)
+      output.puts(librarian.section_names.join("\n"))
+    end
+    if things_to_list.include?(:samples)
+      output.puts(librarian.sample_names.join("\n"))
+    end
+    if things_to_list.include?(:processes)
+      output.puts(librarian.process_names.join("\n"))
+    end
+  end
+
+  def show(source, selection, output=$stdout)
+    librarian = load_librarian(source)
+    selection.fetch(:section, []).each do |section|
+      output.puts(*librarian.section(section))
+    end
+    selection.fetch(:sample, []).each do |sample|
+      output.puts(*librarian.sample(sample))
+    end
+    selection.fetch(:process, []).each do |process|
+      output.puts(*librarian.process(process).command)
+    end
+  end
+
+  def select(source, selector, output=$stdout)
+    librarian = load_librarian(source)
+    output.puts(*librarian[selector])
+  end
+  private
+
+  def load_librarian(source)
+    librarian = Germinate::Librarian.new
+    reader    = Germinate::Reader.new(librarian)
+    source.each_line do |line|
+      reader << line
+    end
+    librarian
+  end
+end

data/lib/germinate/article_editor.rb

@@ -0,0 +1,20 @@
+# An Editor is responsible for selecting hunks of text from a Librarian and
+# assembling them into a list for formatting.
+class Germinate::ArticleEditor
+  def initialize(librarian)
+    @librarian = librarian
+  end
+
+  def each_hunk(&block)
+    librarian.section_names.each do |section_name|
+      yield librarian.section(section_name).resolve_insertions
+      if librarian.has_sample?(section_name)
+        yield librarian.sample(section_name).resolve_insertions 
+      end
+    end
+  end
+
+  private
+
+  attr_reader :librarian
+end

data/lib/germinate/article_formatter.rb

@@ -0,0 +1,75 @@
+require 'ick'
+require 'fattr'
+require File.expand_path("shared_style_attributes", File.dirname(__FILE__))
+
+# A Formatter is responsible for taking content hunks received from an Editor
+# and formatting them for display or publishing.
+class Germinate::ArticleFormatter
+  Ick::Returning.belongs_to self
+  include Germinate::SharedStyleAttributes
+
+  fattr :join_lines             => true
+  fattr :strip_blanks           => true
+  fattr :rstrip_newlines        => true
+  fattr :uncomment              => true
+  fattr :rstrip_lines           => true
+
+  def initialize(output_stream=$stdout)
+    @output_stream  = output_stream
+    @first_output   = true
+  end
+
+  def start!
+  end
+
+  def finish!
+  end
+
+  def format!(hunk)
+    @output_stream.puts unless first_output?
+    hunk.format_with(self)
+    @first_output = false if first_output?
+  end
+
+  def format_text!(hunk, comment_prefix=nil)
+    text_transforms.inject(hunk) do |hunk, transform|
+      transform.call(hunk)
+    end.each do |line|
+      @output_stream.puts(line)
+    end
+  end
+
+  def format_code!(hunk, comment_prefix=nil)
+    code_transforms.inject(hunk) do |hunk, transform|
+      transform.call(hunk)
+    end.each do |line|
+      @output_stream.puts(line)
+    end
+  end
+
+  private
+
+  def first_output?
+    @first_output
+  end
+
+  def text_transforms
+    returning([]) do |transforms|
+      transforms << Germinate::TextTransforms.strip_blanks if strip_blanks?
+      if uncomment?
+        transforms << Germinate::TextTransforms.uncomment(comment_prefix) 
+      end
+      transforms << Germinate::TextTransforms.join_lines if join_lines?
+      transforms << Germinate::TextTransforms.rstrip_lines if rstrip_lines?
+    end
+  end
+
+  def code_transforms
+    returning([]) do |transforms|
+      transforms << Germinate::TextTransforms.strip_blanks if strip_blanks?
+      transforms << Germinate::TextTransforms.rstrip_lines if rstrip_lines?
+      transforms << 
+        Germinate::TextTransforms.bracket
+    end
+  end
+end

data/lib/germinate/formatter.rb

@@ -0,0 +1,119 @@
+require 'alter_ego'
+
+# Obsolete
+class Germinate::Formatter
+  include AlterEgo
+
+  attr_accessor :comment_prefix
+
+  def initialize(output=$stdio)
+    @output = output
+  end
+
+  state :initial, :default => true do
+    transition :to => :code, :on => :start!
+  end
+
+  state :code do
+    handle :add_line!, :add_code_line!
+
+    transition :to => :paragraph, :on => :paragraph!
+    transition :to => :finished, :on => :finish!
+  end
+  
+  state :paragraph do
+    handle :add_line!, :add_paragraph_line!
+
+    transition :to => :linebreak, :on => :linebreak!
+    transition :to => :code, :on => :code!
+    transition :to => :finished, :on => :finish!
+
+    on_exit do
+      flush_paragraph!
+    end
+  end
+
+  state :linebreak do
+    handle :add_line!, :add_linebreak_line!
+
+    transition :to => :paragraph, :on => :paragraph! do
+      emit!("\n")
+    end
+
+    transition :to => :code, :on => :code!
+    transition :to => :finished, :on => :finish!
+
+  end
+
+  state :finished do
+
+  end
+
+  protected
+
+  def add_code_line!(line)
+    case line
+    when /\s*(\S+)?\s*:TEXT:/ then 
+      self.comment_prefix = $1
+      paragraph!
+    end
+  end
+
+  def add_paragraph_line!(line)
+    case line
+    when /:CUT:/
+      code!
+    when text_pattern
+      paragraph_buffer << $1.chomp
+    when whitespace_pattern
+      linebreak!
+    end
+  end
+
+  def add_linebreak_line!(line)
+    case line
+    when /:CUT:/
+      code!
+    when text_pattern
+      paragraph_buffer << $1.chomp
+      paragraph!
+    else
+      # NOOP
+    end
+  end
+
+  private
+
+  attr_reader :output
+
+  def text_pattern
+    if comment_prefix
+      /^\s*#{comment_prefix}+\s*(\S+.*)$/
+    else
+      /^\s*(\S+.*)\s*$/
+    end
+  end
+
+  def whitespace_pattern
+    if comment_prefix
+      /^\s*#{comment_prefix}*\s*$/
+    else
+      /^\s*$/
+    end
+  end
+
+  def paragraph_buffer
+    @paragraph_buffer ||= []
+  end
+
+  def flush_paragraph!
+    emit!(paragraph_buffer.join(" "))
+    paragraph_buffer.clear
+  end
+
+  def emit!(text)
+    unless text.empty?
+      output.puts(text.chomp)
+    end
+  end
+end

data/lib/germinate/hunk.rb

@@ -0,0 +1,149 @@
+require 'ick'
+require File.expand_path("shared_style_attributes", File.dirname(__FILE__))
+
+# A Hunk represents a chunk of content.  There are different types of Hunk, like
+# Code or Text, which may be formatted differently by the Formatter.  At its
+# most basic a Hunk is just a list of Strings, each one representing a single
+# line.
+class Germinate::Hunk < ::Array
+  include Germinate::SharedStyleAttributes
+  Ick::Returning.belongs_to(self)
+
+  def initialize(contents=[], template = {})
+    super(contents)
+    if Germinate::SharedStyleAttributes === template
+      copy_shared_style_attrubutes_from(template)
+    else
+      template.each_pair do |key, value|
+        send(key, value)
+      end
+    end
+  end
+
+  # return a copy with leading and trailing whitespace lines removed
+  def strip
+    Germinate::TextTransforms.strip_blanks.call(self)
+  end
+
+  def resolve_insertions
+    dup.map!{ |line_or_insertion|
+      if line_or_insertion.respond_to?(:resolve)
+        line_or_insertion.resolve
+      else
+        line_or_insertion
+      end
+    }
+  end
+
+  def format_with(formatter)
+    raise "Unresolved hunk cannot be formatted!" unless resolved?
+    if nested_hunks?
+      group_hunks.each do |hunk|
+        hunk.format_with(formatter)
+      end
+    else
+      yield formatter
+    end
+  end
+
+  def inspect
+    attrs = Germinate::SharedStyleAttributes.fattrs.inject({}) {|attrs, key|
+      attrs[key] = send(key)
+      attrs
+    }
+    "#{self.class}:#{super}:#{attrs.inspect}:#{object_id}"
+  end
+
+  def [](*args)
+    returning(super) do |slice|
+      if slice.kind_of?(Germinate::Hunk)
+        slice.copy_shared_style_attrubutes_from(self)
+      end
+    end
+  end
+
+  def slice(*args)
+    returning(super) do |slice|
+      if slice.kind_of?(Germinate::Hunk)
+        slice.copy_shared_style_attrubutes_from(self)
+      end
+    end
+  end
+
+  def index_matching(pattern, start_index=0)
+    (start_index...(size)).each { |i|
+      return i if pattern === self[i]
+    }
+    nil
+  end
+
+  private
+
+  def resolved?
+    !unresolved_hunks?
+  end
+
+  def unresolved_hunks?
+    any?{|line| line.respond_to?(:resolve)}
+  end
+
+  def nested?
+    unresolved_hunks? || nested_hunks?
+  end
+  
+  def nested_hunks?
+    any?{|line| line.respond_to?(:format_with)}
+  end
+
+  def group_hunks
+    return self unless nested?
+    groups = inject([empty_dup]) { |hunks, line_or_hunk|
+      if line_or_hunk.respond_to?(:format_with)
+        hunks << line_or_hunk
+        hunks << empty_dup
+      else
+        hunks.last << line_or_hunk
+      end
+      hunks
+    }
+    groups.delete_if{|g| g.empty?}
+    groups
+  end
+
+  # An empty duplicate retains metadata but has no lines
+  def empty_dup
+    returning(dup) do |duplicate|
+      duplicate.clear
+    end
+  end
+
+end
+
+class Germinate::TextHunk < Germinate::Hunk
+  def format_with(formatter)
+    super(formatter) do |formatter|
+      formatter.format_text!(self, comment_prefix)
+    end
+  end
+end
+
+class Germinate::CodeHunk < Germinate::Hunk
+  def code_open_bracket=(new_value)
+    super
+  end
+
+  def code_close_bracket=(new_value)
+    super
+  end
+
+
+  def format_with(formatter)
+    super(formatter) do |formatter|
+      formatter.format_code!(self, comment_prefix)
+    end
+  end
+end
+
+class Germinate::NullHunk < Germinate::Hunk
+end
+