brief 0.0.5 → 1.0.0

data/lib/brief/model/definition.rb

@@ -0,0 +1,117 @@
+module Brief
+  class Model::Definition
+    attr_accessor :type_alias,
+                  :name,
+                  :metadata_schema,
+                  :content_schema,
+                  :options,
+                  :defined_helpers
+
+    def initialize(name, options={})
+      @name             = name
+      @options          = options
+      @type_alias       = options.fetch(:type_alias) { name.downcase.parameterize.gsub(/-/,'_') }
+      @metadata_schema  = {}.to_mash
+      @content_schema   = {attributes:{}}.to_mash
+      @model_class      = options[:model_class]
+    end
+
+    def valid?
+      name.to_s.length > 0 && type_alias.to_s.length > 0
+    end
+
+    def validate!
+      definition = self
+
+      if valid?
+        create_model_class.tap do |k|
+          k.send(:include, Brief::Model)
+
+          k.definition = definition
+
+          k.name ||= name
+          k.type_alias ||= type_alias
+
+          Brief::Model.classes << k
+        end
+
+        apply_config
+      end
+    end
+
+    def apply_config
+      metadata_schema.values.each do |settings|
+        if model_class.nil?
+          binding.pry
+        end
+
+        model_class.send(:attribute, *(settings[:args]))
+      end
+
+      Array(self.defined_helpers).each do |mod|
+        model_class.send(:include, mod)
+      end
+    end
+
+    def create_model_class
+      model_namespace.const_set(type_alias.camelize, Class.new) unless model_class
+    end
+
+    def model_class
+      @model_class || model_namespace.const_get(type_alias.camelize) rescue nil
+    end
+
+    def model_namespace
+      Brief.configuration.model_namespace || Brief::Model
+    end
+
+    def meta(options={}, &block)
+      @current = :meta
+      instance_eval(&block)
+    end
+
+    def content(options={}, &block)
+      @current = :content
+      instance_eval(&block)
+    end
+
+    def helpers(&block)
+      self.defined_helpers ||= []
+
+      if block
+        mod = Module.new
+        mod.module_eval(&block)
+
+        self.defined_helpers << mod
+      end
+    end
+
+    def inside_meta?
+      @current == :meta
+    end
+
+    def inside_content?
+      @current == :content
+    end
+
+    def method_missing(meth, *args, &block)
+      args = args.dup
+
+      if inside_content?
+        if meth.to_s == :define_section
+
+        end
+
+        self.content_schema.attributes[meth] = {args: args, block: block}
+      elsif inside_meta?
+        if args.first.is_a?(Hash)
+          args.unshift(String)
+        end
+        args.unshift(meth)
+        self.metadata_schema[meth] = {args: args, block: block}
+      else
+        super
+      end
+    end
+  end
+end

data/lib/brief/model.rb

@@ -0,0 +1,177 @@
+module Brief
+  module Model
+    extend ActiveSupport::Concern
+
+    included do
+      unless defined?(Virtus)
+        require 'inflecto'
+        require 'virtus'
+      end
+
+      include Virtus.model(finalize: false)
+      include Initializers
+      include AccessorMethods
+      include Persistence
+
+      class_attribute :models, :after_initialization_hooks, :defined_helpers
+
+      self.models = Array(self.models).to_set
+
+      class << self
+        include Enumerable
+      end
+
+      attribute :path, Pathname
+      attribute :document, Brief::Document
+
+      Brief::Model.classes << self
+    end
+
+    module AccessorMethods
+      def data
+        document.data
+      end
+
+      def content
+        document.content
+      end
+
+      def extracted
+        @extracted ||= Brief::Document::ContentExtractor.new(self.class.type_alias, document)
+      end
+
+      def method_missing(meth, *args, &block)
+        if args.empty?
+          if document.respond_to?(meth)
+            document.send(meth)
+          else
+            document.data.key?(meth) ? data[meth] : extracted.send(meth)
+          end
+        else
+          super
+        end
+      end
+    end
+
+    def self.classes
+      @classes ||= Set.new
+    end
+
+    def self.table
+      classes.inject({}.to_mash) do |memo, klass|
+        memo.tap { memo[klass.type_alias] = klass }
+      end
+    end
+
+    def self.for_type(type_alias)
+      table[type_alias]
+    end
+
+    def self.finalize
+      Virtus.finalize
+
+      classes.each do |klass|
+        klass.name ||= klass.to_s.split('::').last.humanize
+        klass.type_alias ||= klass.name.parameterize.gsub(/-/,'_')
+
+        klass.attribute_set.map(&:name).each do |attr|
+          klass.define_singleton_method("find_by_#{ attr }") do |value|
+            where(attr => value).first
+          end
+        end
+
+        klass.definition.apply_config
+      end
+
+      Brief::Repository.define_document_finder_methods
+    end
+
+    def ==(other)
+      self.path == other.path
+    end
+
+    def extract_content(options={})
+      document.extract_content(options)
+    end
+
+    module ClassMethods
+      def where(*args, &block)
+        Brief::DocumentMapper::Query.new(self).send(:where, *args)
+      end
+
+      def each(*args, &block)
+        Array(self.models).send(:each, *args, &block)
+      end
+
+      def meta(options={}, &block)
+        definition.send(:meta, options, &block)
+      end
+
+      def content(options={}, &block)
+        definition.send(:content, options, &block)
+      end
+
+      def actions(&block)
+        definition.send(:helpers, &block)
+      end
+
+      def after_initialize(&block)
+        (self.after_initialization_hooks ||= []).push(block)
+      end
+
+      def name=(value)
+        @name = value
+      end
+
+      def name
+        @name || to_s.split('::').last.underscore.gsub('_',' ').titlecase
+      end
+
+      def type_alias=(value)
+        @type_alias = value
+      end
+
+      def type_alias
+        @type_alias || name.parameterize.gsub(/-/,'_')
+      end
+
+      def definition
+        @definition ||= Brief::Model::Definition.new(name, type_alias: type_alias, model_class: self)
+      end
+
+      def definition=(value)
+        @definition
+      end
+
+      def method_missing(meth, *args, &block)
+        if meth.to_s.match(/^on_(.*)_change$/)
+          create_change_handler($1, *args, &block)
+        else
+          super
+        end
+      end
+
+      def create_change_handler(attribute, *args, &block)
+        block.call(self)
+      end
+    end
+
+    module Initializers
+      def set_default_attributes
+        attribute_set.set_defaults(self)
+        send(:after_initialize) if respond_to?(:after_initialize)
+        self
+      end
+
+      def after_initialize
+        Array(self.class.after_initialization_hooks).each do |hook|
+          hook.call(self)
+        end
+      end
+
+      def set_slug_from(column=:name)
+        self.slug = send(column).to_s.downcase.parameterize if self.slug.to_s.length == 0
+      end
+    end
+  end
+end

data/lib/brief/repository.rb

@@ -0,0 +1,57 @@
+module Brief
+  class Repository
+    attr_reader :briefcase, :options
+
+    include Enumerable
+
+    # should compare vs yield
+    def each(*args, &block)
+      documents.send(:each, *args, &block)
+    end
+
+    def initialize(briefcase, options={})
+      @briefcase = briefcase
+      @options = options
+
+      load_documents
+    end
+
+    def documents
+      return @documents if @documents
+      load_documents
+    end
+
+    def where(*args)
+      Brief::DocumentMapper::Query.new(self).send(:where, *args)
+    end
+
+    def order_by(*args)
+      Brief::DocumentMapper::Query.new(self).send(:order_by, *args)
+    end
+
+    def root
+      briefcase.root
+    end
+
+    def load_documents
+      @documents = document_paths.map do |path|
+        Brief::Document.new(path)
+      end
+    end
+
+    def document_paths
+      Dir[root.join("**/*.md").to_s]
+    end
+
+    def self.define_document_finder_methods
+      # Create a finder method on the repository
+      # which lets us find instances of models by their class name
+      Brief::Model.table.keys.each do |type|
+        define_method(type.to_s.pluralize) do
+          Brief::Model.for_type(type).models.to_a
+        end
+      end
+    end
+
+  end
+end

data/lib/brief/version.rb

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

data/lib/brief.rb

@@ -1,56 +1,51 @@
-lib = File.dirname(__FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "pathname"
+require "set"
+require "hashie"
+require "virtus"
+require "inflecto"
+require "active_support"
+require "active_support/core_ext"
+require "redcarpet"
+require "nokogiri"
+require "yaml"
 
 module Brief
-  # Haven't decided if the brief config system should support different profiles or not
-  def self.profile
-    configuration
+  def self.case= value
+    @briefcase = value
   end
 
-  def self.config
-    configuration
+  def self.case
+    @briefcase
   end
 
   def self.configuration
-    @configuration ||= Brief::Configuration.instance
-  end
-
-  def self.root
-    Pathname(Dir.pwd())
+    Brief::Configuration.instance
   end
 
   def self.gem_root
     Pathname(File.dirname(__FILE__))
   end
 
-  def self.define publisher_name, &config
-    Brief::Publisher.define(publisher_name, &config)
+  def self.load_commands
+    Dir[gem_root.join("brief","cli","**/*.rb")].each {|f| require(f) }
   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'
+  def self.load_models(from_folder=nil)
+    Brief::Model.load_all(from_folder: from_folder)
+  end
+end
 
-# these may be optional one day
-require 'brief/github'
-require 'brief/git'
-require 'brief/github/wiki'
+require "brief/core_ext"
+require "brief/version"
+require "brief/configuration"
+require "brief/document/rendering"
+require "brief/document/front_matter"
+require "brief/document/content_extractor"
+require "brief/document"
+require "brief/document_mapper"
+require "brief/repository"
+require "brief/model"
+require "brief/model/definition"
+require "brief/model/persistence"
+require "brief/dsl"
+require "brief/briefcase"

data/spec/fixtures/example/brief.rb

@@ -0,0 +1,27 @@
+config do
+  set(:models => Pathname(File.dirname(__FILE__)).join("models"))
+end
+
+define "User Story" do
+  meta do
+    title
+    status :in => %w(draft published)
+    epic_title
+  end
+
+  content do
+    persona "p strong:first-child"
+    behavior "p strong:second-child"
+    goal "p strong:third-child"
+  end
+
+  helpers do
+    def defined_helper_method
+      true
+    end
+  end
+end
+
+action "custom command" do
+  $custom_command = true
+end

data/spec/fixtures/example/docs/concept.html.md

@@ -0,0 +1,5 @@
+---
+type: concept
+title: Blueprint Concept Example
+subheading: A key concept to the domain model 
+---

data/spec/fixtures/example/docs/epic.html.md

@@ -0,0 +1,19 @@
+---
+type: epic
+title: Blueprint Epic Example
+subheading: An example of an Epic
+state: active
+---
+
+# Blueprint Epic Example
+
+This is an example of an Epic Document.  An Epic is a single document
+which contains user stories and such.
+
+# User Stories
+
+## A user wants to write epics
+
+## A user wants to annotate wireframes
+
+## A user wants to provide details about domain concepts

data/spec/fixtures/example/docs/persona.html.md

@@ -0,0 +1,5 @@
+---
+type: persona
+title: Blueprint Persona Example
+subheading: A description of a typical user of the software 
+---

data/spec/fixtures/example/docs/release.html.md

@@ -0,0 +1,7 @@
+---
+type: release
+title: Blueprint Release Example
+subheading: A release milestone for the software 
+status: Planned
+date: 2018-12-18
+---

data/spec/fixtures/example/docs/resource.html.md

@@ -0,0 +1,5 @@
+---
+type: resource
+title: Blueprint Example Resource
+subheading: An example API Resource document
+---

data/spec/fixtures/example/docs/user_story.html.md

@@ -0,0 +1,24 @@
+---
+type: user_story
+title: Blueprint User Story Example
+subheading: A way of describing desired behavior of the software, from the perspective of a persona who has a goal 
+epic: Blueprint Epic Example 
+release: Blueprint Release Example
+state: active
+title: A Blueprint Persona Example wants this behavior
+---
+
+As a **Blueprint Persona Example** I would like to **do this certain thing in the software** so that I can **accomplish this goal**
+
+#### Wireframes
+
+- Blueprint Wireframe Example
+
+#### Concepts
+
+- Blueprint Concept Example
+
+#### Resources
+
+- Blueprint Example Resource
+

data/spec/fixtures/example/docs/wireframe.html.md

@@ -0,0 +1,5 @@
+---
+type: wireframe
+title: Blueprint Wireframe Example
+subheading: A key concept to the domain model 
+---

data/spec/fixtures/example/models/epic.rb

@@ -0,0 +1,16 @@
+class Brief::Epic
+  include Brief::Model
+
+  meta do
+    title String
+    status String, :in => %w(draft published)
+  end
+
+  content do
+    title "h1:first-child"
+
+    define_section "User Stories" do
+      has_many :user_stories, "h2" => "title", "p:first-child" => "paragraph"
+    end
+  end
+end

data/spec/lib/brief/briefcase_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+describe "The Briefcase" do
+  let(:briefcase) { Brief.example }
+
+  it "has a root path" do
+    expect(briefcase.root).to be_exist
+  end
+
+  it "points to a file repository" do
+    expect(briefcase.repository).to be_a(Brief::Repository)
+  end
+
+  context "Model Loading" do
+    it "loads the model definitions from the models folder" do
+    end
+
+    it "loads the model definitions from the DSL in the config file" do
+    end
+  end
+
+  context "Document Mappings" do
+    it "has all of the documents" do
+
+    end
+  end
+end

data/spec/lib/brief/document_spec.rb

@@ -1,35 +1,27 @@
 require "spec_helper"
 
-describe Brief::Document do
-  let(:path) { Brief.fixtures.join("sample.md") }
-
-  let(:tutorial) do
-    Brief::Document.new(path: path)
+describe "The Brief Document" do
+  let(:sample) do
+    path = Brief.example_path.join("docs","epic.html.md")
+    Brief::Document.new(path)
   end
 
-  it "should let me pass raw markdown" do
-    level_one = Brief::Document.new(path.read).tree.level(1)
-    expect(level_one.first.title).to eq("Heading One")
+  it "renders html" do
+    expect(sample.to_html).to include("<h1>User Stories</h1>")
   end
 
-  it "should let me pass a markdown file" do
-    level_one = Brief::Document.new(path).tree.level(1)
-    expect(level_one.first.title).to eq("Heading One")
+  it "parses the html" do
+    expect(sample.css("h1").length).to eq(2)
   end
 
-  describe "Parsers and Publishers" do
-    it "should have a parser" do
-      expect(tutorial.parser).not_to be_nil
-    end
-
-    it "should have a publisher" do
-      expect(tutorial.publisher).not_to be_nil
-    end
+  it "deserializes YAML frontmatter into attributes" do
+    expect(sample.frontmatter.type).to eq("epic")
   end
 
-  describe "Finding code blocks by language" do
-    it "should find the blocks of code and group them by their language" do
-      expect(tutorial.code_blocks_by_language).not_to be_empty
+  context "Content Extraction" do
+    it "extracts content from a css selector" do
+      extracted = sample.extract_content(:args => ["h1:first-child"])
+      expect(extracted).to eq("Blueprint Epic Example")
     end
   end
 end

data/spec/lib/brief/dsl_spec.rb

@@ -1,21 +1,10 @@
 require "spec_helper"
 
-describe "The Publisher definition DSL" do
-  before(:all) do
-    require Brief.fixtures.join("generator_dsl_example.rb")
-  end
-
-  it "should define a generator called Project Overview" do
-    expect(Brief::Publisher.fetch("Project Overview")).to be_present
-  end
 
-  it "should find the appropriate Publisher by using an alias" do
-    expect(Brief::Publisher.fetch("project_overview")).to be_present
-  end
+describe "The Configuration DSL" do
+  let(:briefcase) { Brief.example }
 
-  it "should find the appropriate Publisher using a case insensitve search" do
-    expect(Brief::Publisher.fetch("project overview")).to be_present
+  it "can create methods on our models" do
+    expect(briefcase.user_stories.first.defined_helper_method).to eq(true)
   end
-
-
 end