brief 0.0.5 → 1.0.0

data/lib/brief/parser.rb

@@ -1,354 +0,0 @@
-# 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).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

@@ -1,47 +0,0 @@
-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

@@ -1,142 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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.each {|gchild| gchild.parent_id = c_only.id}
-
-                          g_children  = nil if g_children.length == 0
-
-                          [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/core_ext.rb

@@ -1,37 +0,0 @@
-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'

data/spec/fixtures/front_end_tutorial.md

@@ -1,33 +0,0 @@
-# Backbone View Tutorial
-
-Below is an example of how you can style a backbone view.
-
-## Template Content
-
-First write a basic template.
-
-```slim
-nav.nav.navbar-inverse
-  .container
-    .row-fluid
-```
-
-## Style Content
-
-Make the text pink, because it is manly.
-
-```scss
-nav.navbar-inverse {
-  color: pink;
-}
-```
-
-## Script Content
-
-Then you'll wanna do some stuff with the coffeescript.
-
-```coffeescript
-MyView = Backbone.View.extend
-  className: "navbar-inverse"
-```
-

data/spec/fixtures/generator_dsl_example.rb

@@ -1,22 +0,0 @@
-Brief.define "Project Overview" do
-  aliases :project_overview
-
-  levels do
-    level(1) do
-      name "Wiki Page"
-      define_handler :create => "Brief::Handlers::GithubWiki"
-      replaces_items_from_level 2, :with => "Brief::Formatters::GithubMilestoneRollup"
-    end
-
-    level(2) do
-      name "Github Milestone"
-      define_handler :create => "Brief::Handlers::GithubMilestone"
-      replaces_items_from_level 3, :with => nil
-    end
-
-    level(3) do
-      name "Github Issue"
-      define_handler :create => "Brief::Handlers::GithubIssue"
-    end
-  end
-end