brief 0.0.1 → 0.0.2

data/lib/brief/parser.rb

@@ -0,0 +1,354 @@
+# This is my first attempt at breaking down raw markdown
+# into a tree / hierarchy, so that it can be used to do other
+# things / create other entities.
+#
+module Brief
+  class Parser
+    attr_accessor :content, :options, :raw_tree, :checksum
+
+    # Regexes
+    HeadingRegex      = /^#+/
+
+    # Exceptions
+    MissingHeadings   = Class.new(Exception)
+    HeadingsNotUnique = Class.new(Exception)
+
+    def initialize(content="",options={})
+      @options = options.dup
+      @content = content
+      @checksum = options.fetch(:checksum, Digest::MD5.hexdigest(content))
+
+      scan
+      parse
+    end
+
+    def tree
+      @tree ||= Brief::Tree.new(tree_nodes.dup.freeze)
+    end
+
+    def items(sorted=true)
+      sorted ? tree.items.sort_by(&:sort_index) : tree.items
+    end
+
+    def headings_at_level level, options={}
+      as_objects = options.fetch(:as_objects, false)
+      items = heading_lines.select {|line| line.level == level }.sort_by(&:sort_index)
+      as_objects ? items : items.map(&:content)
+    end
+
+    def next_sibling_of(heading_line)
+      if heading_line.is_a?(String)
+        heading_line = heading_lines.detect {|h| h.content == heading_line }
+      end
+
+      heading_lines.detect {|l| l.level <= heading_line.level && l.number > heading_line.number }
+    end
+
+    def body_content_for(heading_line)
+      if heading_line.is_a?(String)
+        heading_line = heading_lines.detect {|h| h.content == heading_line }
+      end
+
+      min = heading_line.number + 1
+      max = next_sibling_of(heading_line).try(:number).try(:-, 1) || last_line_number
+
+      parsed_lines.select {|p| p.number.between?(min,max) }.map(&:raw).map(&:strip).join("")
+    end
+
+    def lines_between_boundaries *bounds
+      bounds.map do |range|
+        a = range.min - 1
+        b = range.max - a
+        parsed_lines.slice(a, b).map(&:raw)
+      end
+    end
+
+    def last_line_number
+      parsed_lines.last.try(:number) || raw_lines.length + 1
+    end
+
+    def parser
+      self
+    end
+
+    def extract_frontmatter!
+      if raw_lines.any? {|l| l.match(/```settings/) }
+        markers = identify_codemarkers
+
+        if raw_lines[markers.first].to_s.match(/```settings/)
+          length = markers[1] - markers[0]
+          @front_matter = raw_lines.slice(markers[0] + 1, length - 1).join
+          remove_raw_lines(markers[0], markers[1])
+          @content = raw_lines.join.gsub(/^\n|\n$/,'')
+        end
+      end
+    end
+
+    def front_matter
+      YAML.load(@front_matter) rescue {}
+    end
+
+    def identify_codemarkers
+      markers = []
+      raw_lines.each_with_index do |line, index|
+        if line.match(Brief::Line::CodeBlockRegex)
+          markers << index
+        end
+      end
+
+      markers
+    end
+
+    def scan
+      extract_frontmatter!
+
+      @code_markers = identify_codemarkers
+      @heading_markers = identify_heading_markers
+
+      @scanned = true
+    end
+
+    def identify_heading_markers
+      heading_markers = []
+      raw_lines.each_with_index do |line, index|
+        if line.match(Brief::Line::HeadingRegex) && !is_line_inside_code_region?(index)
+          heading_markers << index
+        end
+      end
+      heading_markers
+    end
+
+    def heading_boundaries
+      @heading_markers && @heading_markers.each_slice(2).map do |slice|
+        Range.new slice.first + 1, slice.last + 1
+      end
+    end
+
+    def code_boundaries
+      @code_markers && @code_markers.each_slice(2).map do |slice|
+        Range.new slice.first + 1, slice.last + 1
+      end
+    end
+
+    def valid?
+      @validated.presence || validate
+    end
+
+    def validate
+      scan unless @scanned
+
+      unless heading_lines.length > 0
+        raise MissingHeadings, 'A Brief must include some headings'
+      end
+
+      if heading_lines.uniq.length < heading_lines.length
+        raise HeadingsNotUnique, 'Headings inside a brief must be unique'
+      end
+
+      @validated = true
+    end
+
+    # This syntax isn't right, but it works.
+    # TODO: Research the best way to do this.
+    # middleman had an example of using the &method(:method_name)
+    # to treat a method definition as a proc
+    def tree_visitor node
+      subheadings = headings_under(node, as_objects: true)
+      children = subheadings.map(&method(:tree_visitor))
+      id = "#{ checksum }_#{ node.sort_index.join('_') }"
+
+      children.each_with_index do |child, index|
+        child[:heading_index] = index
+      end
+
+      base = {
+        id: id,
+        level: node.level,
+        children: children,
+        title: node.content,
+        sort_index: node.sort_index,
+        line_number: node.line_number
+      }
+
+      base.merge! content: body_content_for(node).to_s.strip if node.heading?
+
+      base
+    end
+
+    def tree_nodes
+      @tree_nodes ||= begin
+                        nodes = []
+
+                        headings_at_level(highest_level, as_objects: true).each_with_index do |node, index|
+                          element = tree_visitor(node)
+                          element[:heading_index] = index
+                          nodes << element
+                        end
+
+                        nodes.map {|node| Hashie::Mash.new(node) }.flatten
+                      end
+    end
+
+    def elements
+      @elements ||= tree.elements
+    end
+
+    def maximum_level
+      elements.map(&:level).max
+    end
+
+    def line_at(number)
+      parsed_lines.detect {|line| line.number == number }
+    end
+
+    def index_of(line)
+      lines.index(line)
+    end
+
+    def next_heading_after heading, options={}
+      heading_lines.detect {|line| line.number > heading.number }
+    end
+
+    def highest_level
+      level_boundaries.last
+    end
+
+    def lowest_level
+      level_boundaries.first
+    end
+
+    def level_boundaries
+      levels = heading_lines.map(&:level).uniq
+      [levels.max, levels.min]
+    end
+
+    def heading_lines
+      parsed_lines.select do |line|
+        line.heading?
+      end
+    end
+
+    def is_line_inside_code_region?(line_number)
+      code_boundaries.any? {|range| range.include?(line_number) }
+    end
+
+    def headings_after(heading_line)
+      if heading_line.is_a?(String)
+        heading_line = heading_lines.detect {|h| h.content == heading_line }
+      end
+
+      heading_lines.select {|line| line.number > heading_line.number }
+    end
+
+    def headings_under(heading_line, options={})
+      matches = []
+      continue = true
+
+      include_subtree = options.fetch(:all, false)
+      as_objects      = options.fetch(:as_objects, false)
+
+      if heading_line.is_a?(String)
+        heading_line = heading_lines.detect {|h| h.content == heading_line }
+      end
+
+      headings_after(heading_line).each do |line|
+        continue = false if line.level <= heading_line.level
+        if continue && line.level > heading_line.level
+          matches << line unless (!include_subtree && line.level - heading_line.level > 1)
+        end
+      end
+
+      as_objects ? matches : matches.map(&:content)
+    end
+
+    def content_lines_under(heading_line, options={})
+      reject_blank  = !options.fetch(:include_blank, true)
+      as_objects    = options.fetch(:as_objects, false)
+
+      if heading_line.is_a?(String)
+        heading_line = heading_lines.detect {|h| h.content == heading_line }
+      end
+
+      return [] unless heading_line.respond_to?(:number)
+
+      min = heading_line.number
+      max = next_heading_after(heading_line).try(:number) || last_line_number
+
+      matches = content_lines.select do |line|
+        line.content? && line.number.between?(min, max)
+      end
+
+      matches.reject! {|m| m.content.blank? } if reject_blank
+
+      as_objects ? matches : matches.map(&:content)
+    end
+
+    def content_lines
+      parsed_lines.select(&:content?)
+    end
+
+    def code_block_markers
+      parsed_lines.select {|l| l.type == "code_block_marker" }
+    end
+
+    def raw_lines
+      @raw_lines ||= @content.lines.to_a
+    end
+
+    # I really need to get better with arrays
+    def remove_raw_lines start_index, end_index
+      original = @raw_lines.dup
+      copy = []
+
+      original.each_with_index do |line, index|
+        copy.push(line) unless index.between? start_index, end_index
+      end
+
+      @raw_lines = copy
+    end
+
+    def stripped_lines
+      @stripped ||= raw_lines.map(&:strip)
+    end
+
+    def parsed_lines
+      @parsed_lines
+    end
+
+    def parse clear=false
+      @parsed_lines = nil if clear
+
+      return @parsed_lines if @parsed_lines
+
+      parsed = []
+
+      raw = raw_lines
+
+      stripped_lines.each_with_index do |line,index|
+        is_code = code_boundaries.any? {|bounds| bounds.include?(index) }
+        line = Brief::Line.new(line, index, is_code)
+        line.raw = raw[index]
+        parsed << line
+      end
+
+      @parsed_lines = parsed
+    end
+
+    def code_blocks_by_language
+      return @code_samples if @code_samples
+
+       bounds = Array(parser && parser.send(:code_boundaries))
+       sections = parser.lines_between_boundaries(*bounds)
+
+        @code_samples = sections.inject({}) do |memo,section|
+          marker    = section.first.split('```').last
+          language  = marker.nil? ? :text : marker.strip
+
+          section.shift && section.pop
+          memo[language.to_sym] ||= []
+          memo[language.to_sym] << section.join("").sub(/^\s+/,'')
+          memo
+        end
+    end
+  end
+end

data/lib/brief/publisher/handler_manager.rb

@@ -0,0 +1,47 @@
+module Brief
+  class Publisher::HandlerManager
+
+    attr_reader :publisher, :document
+
+    def initialize(publisher, document)
+      @publisher  = publisher
+      @document   = document
+    end
+
+    def parser
+      @parser ||= document.parser
+    end
+
+    def handlers
+      find_parent = lambda do |parent_id|
+        parser.tree.find(parent_id)
+      end
+
+      get_manager = -> { self }
+
+      @handlers ||= publisher.order.inject({}) do |memo, level|
+        config            = publisher.config_for_level(level)
+        klass_name        = config.publish.klass
+        klass             = klass_name.nil? ? Brief::Handlers::Base : (klass_name.to_s.constantize rescue Brief::Handlers::Base)
+
+        memo[level] = parser.tree.level(level).map do |element|
+          obj = klass.new(element)
+
+          obj.parent(&find_parent)
+          obj.get_manager(&get_manager)
+
+          obj
+        end
+
+        memo
+      end
+    end
+
+    def run
+      publisher.order.each do |level|
+        objects = handlers[level]
+        objects.each(&:handle!)
+      end
+    end
+  end
+end

data/lib/brief/publisher.rb

@@ -0,0 +1,142 @@
+module Brief
+  class Publisher
+
+    class << self
+      attr_accessor :defined, :aliases
+    end
+
+    self.defined ||= {}
+    self.aliases ||= {}
+
+    def self.find query
+      query = query.join(" ") if query.respond_to?(:to_ary)
+
+      if defined[query].nil? && aliases.has_key?(query)
+        return find(aliases[query])
+      end
+
+      result = defined[query]
+
+      result
+    end
+
+    def self.publisher publisher_name
+      defined[key]
+    end
+
+    def self.define publisher_name, &config
+      obj = defined[publisher_name] ||= Brief::Publisher.new(publisher_name)
+      obj.instance_eval(&config) if block_given?
+
+      aliases[publisher_name.downcase] ||= obj.name
+
+      obj.aliases.each do |alias_name|
+        aliases[alias_name.to_s] ||= obj.name
+      end
+
+      obj
+    end
+
+    def process document
+      @manager = Brief::Publisher::HandlerManager.new(self, document).run
+    end
+
+    attr_accessor :command_alias, :sample, :name, :options
+
+    def initialize(name, options={})
+      @name           = name
+      @options        = options
+      @command_alias  = options[:command_alias]
+
+      @before_blocks = {}
+    end
+
+    def before event_name, &block
+      (@before_blocks[event_name.to_sym] ||= []).push(block)
+    end
+
+    def run_before_hooks event_name, &success
+      results = Array(@before_blocks[event_name.to_sym]).map do |hook|
+        hook.call if hook.respond_to?(:call)
+      end
+
+      unless results.any? {|r| r == false }
+        instance_eval(&success) if block_given?
+      end
+    end
+
+    def required_inputs
+      @options[:required_inputs] ||= {}
+    end
+
+    def requires_input field, options={}
+      cfg = required_inputs.fetch(field.to_sym) { options }
+      cfg.reverse_merge(options)
+    end
+
+    def levels &block
+      @state = :levels
+      instance_eval(&block) if block_given?
+    end
+
+    def sample sample_markdown=nil
+      options[:sample] = "#{sample_markdown}".gsub(/^\s+/,'') if sample_markdown
+      options[:sample]
+    end
+
+    def aliases *values
+      @command_aliases ||= []
+      @command_aliases += values
+      @command_aliases.uniq
+    end
+
+    def maximum_level
+      @maximum_level
+    end
+
+    def current_level
+      @current_level || 1
+    end
+
+    def order *levels
+      @order = levels if levels && levels.length > 0
+      @order || maximum_level.times.map {|n| n + 1 }
+    end
+
+    def level level_number, &block
+      @state          = :level
+      @maximum_level  = [@current_level || 0, level_number].compact.map(&:to_i).max
+      @current_level  = level_number
+      instance_eval(&block) if block_given?
+    end
+
+    def level_config
+      @level_config ||= Hashie::Mash.new({})
+    end
+
+    def config_for_level level
+      level_config["level_#{level}".to_sym] ||= {}
+    end
+
+    def current_level_config
+      config_for_level(current_level)
+    end
+
+    def desc description
+      current_level_config[:description] = description
+    end
+
+    def define_handler handler, options={}
+      if options.is_a?(String)
+        options = {klass: options.classify}
+      end
+
+      current_level_config[handler] = options
+    end
+
+    def replaces_items_from_level n, options={}
+      current_level_config[:replace_options] = options
+    end
+
+  end
+end

data/lib/brief/tree.rb

@@ -0,0 +1,42 @@
+module Brief
+  class Tree
+    def initialize(nodes)
+      @nodes = nodes
+    end
+
+    def find element_by_id
+      elements.detect {|el| el.id == element_by_id }
+    end
+
+    def elements
+      @elements ||= begin
+                      @nodes.map do |node|
+                        only      = node.except(:children)
+
+                        visitor = lambda do |child|
+                          c_only      = child.except(:children)
+                          g_children  = Array(child[:children])
+                          g_children  = nil if g_children.length == 0
+
+                          g_children.each {|gchild| gchild.parent_id = c_only.id}
+
+                          [c_only, g_children].compact
+                        end
+
+                        children = Array(node[:children]).map(&visitor).flatten
+                        children.each {|child| child.parent_id ||= only.id }
+
+                        children = nil if children.length == 0
+
+                        [only, children].compact
+                      end
+
+                    end.flatten
+    end
+
+    def level level=1
+      elements.select {|el| el.level == level }
+    end
+
+  end
+end

data/lib/brief/version.rb

@@ -0,0 +1,9 @@
+module Brief
+  MAJOR     = 0
+  MINOR     = 0
+  REVISION  = 1
+
+  Version   = "#{ MAJOR }.#{ MINOR }.#{ REVISION }"
+
+  VERSION   = Version
+end

data/lib/brief.rb

@@ -0,0 +1,56 @@
+lib = File.dirname(__FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+module Brief
+  # Haven't decided if the brief config system should support different profiles or not
+  def self.profile
+    configuration
+  end
+
+  def self.config
+    configuration
+  end
+
+  def self.configuration
+    @configuration ||= Brief::Configuration.instance
+  end
+
+  def self.root
+    Pathname(Dir.pwd())
+  end
+
+  def self.gem_root
+    Pathname(File.dirname(__FILE__))
+  end
+
+  def self.define publisher_name, &config
+    Brief::Publisher.define(publisher_name, &config)
+  end
+end
+
+require 'pathname'
+require 'hashie'
+require 'digest'
+require 'yaml'
+
+require 'active_support'
+require 'active_support/core_ext'
+
+require 'brief/line'
+require 'brief/parser'
+require 'brief/document'
+require 'brief/tree'
+require 'brief/version'
+require 'brief/configuration'
+
+require 'brief/publisher'
+require 'brief/publisher/handler_manager'
+# These should be able to be loaded separately
+# some other way, but to help develoment..
+require 'brief/handlers/base'
+require 'brief/formatters/base'
+
+# these may be optional one day
+require 'brief/github'
+require 'brief/git'
+require 'brief/github/wiki'

data/lib/core_ext.rb

@@ -0,0 +1,37 @@
+class Object
+  def present?
+    !nil?
+  end
+
+  def try(*a, &b)
+    if a.empty? && block_given?
+      yield self
+    else
+      public_send(*a, &b) if respond_to?(a.first)
+    end
+  end
+
+  def try!(*a, &b)
+    if a.empty? && block_given?
+      yield self
+    else
+      public_send(*a, &b)
+    end
+  end
+end
+
+class NilClass
+  def present?
+    false
+  end
+  def try(*args)
+    nil
+  end
+
+  def try!(*args)
+    nil
+  end
+end
+
+require 'core_ext/hash'
+require 'core_ext/string'