brief 0.0.5 → 1.0.0

data/lib/brief/cli/change.rb

@@ -0,0 +1,14 @@
+command "change" do |c|
+  c.syntax = "brief change ATTRIBUTE [OPTIONS]"
+  c.description = "change attributes of brief documents"
+
+  c.option "--from", String, "Only apply when the attributes current value matches."
+  c.option "--to", String, "Only apply when the attributes current value matches."
+  c.option "--files", String, "The files you want to change"
+  c.option "--on", String, "alias for --files. The files you want to change"
+
+  c.action do |args, options|
+    puts "Args: #{ args.inspect }"
+    puts "Options: #{ options.inspect }"
+  end
+end

data/lib/brief/cli/init.rb

@@ -0,0 +1,66 @@
+command "init" do |c|
+  c.syntax = "brief init NAME [OPTIONS]"
+  c.description = "Create a new brief project, aka a briefcase"
+
+  c.option "--root", String, "The root folder for the new project."
+
+  c.action do |args, options|
+    options.default(:root => Dir.pwd())
+
+    if path = args.first
+      root = Pathname(options.root).join(path)
+    end
+
+    [root, root.join("models"), root.join("docs")].each do |p|
+      puts "== folder #{ p.basename } #{ '. exists' if p.exist? }"
+      FileUtils.mkdir_p(p) unless p.exist?
+    end
+
+
+    if root.join("brief.rb").exist?
+      say "== Briefcase config already exists. Skipping."
+    else
+      say "== Creating config file brief.rb"
+      root.join("brief.rb").open("w+") do |fh|
+        default_config = <<-EOF
+
+config do
+  set(:models_path => Pathname(__FILE__).parent.join("models"))
+end
+
+define("Post") do
+  meta do
+    status
+    date DateTime, :default => lambda {|post, attr| post.document.created_at }
+  end
+
+  content do
+    title "h1"
+    has_many :subheadings, "h2"
+  end
+
+  helpers do
+    def publish(options={})
+      post.set(:status, "published")
+      post.save
+    end
+  end
+
+  on_status_change(:from => "draft", :to => "published") do |model|
+    # Do Something
+    # mail_service.send_html_email_campaign(model.to_html)
+  end
+end
+
+# brief publish posts /path/to/*.html.md
+action "publish posts" do |briefcase, models, options|
+  models.each do |post|
+    post.publish(options)
+  end
+end
+        EOF
+        fh.write(default_config)
+      end
+    end
+  end
+end

data/lib/brief/configuration.rb

@@ -1,134 +1,38 @@
-require "singleton"
-require "json"
+require 'singleton'
 
 module Brief
   class Configuration
     include Singleton
 
-    DefaultSettings = {
-      github_username: "",
-      github_api_token: ""
-    }
-
-    def self.method_missing meth, *args, &block
+    def self.method_missing(meth, *args, &block)
       if instance.respond_to?(meth)
-        return instance.send meth, *args, &block
-      end
-
-      nil
-    end
-
-    def initialize!
-      FileUtils.mkdir_p home_config_path.dirname
-    end
-
-    def method_missing meth, *args, &block
-      if current.has_key?(meth.to_s)
-        return current.fetch(meth)
-      end
-
-      super
-    end
-
-    def current_github_repository
-      value = current.github_repository
-
-      return value if value
-
-      if value.nil?
-        if guess = Brief::Git.current_github_repository
-          set "github_repository", guess
-          return guess
-        end
+        instance.send(meth, *args, &block)
+      else
+        super
       end
-
-      current.github_repository
     end
 
     def current
-      @current ||= begin
-                     home_config.merge(cwd_config)
-                   end
+      @current ||= {
+        docs_path: "docs",
+        models_path: "models"
+      }.to_mash
     end
 
-    def current_config
-      cwd_config_path.exist? ? cwd_config : home_config
+    def set(attribute, value=nil)
+      current[attribute] = value
+      self
     end
 
-    def set setting, value, persist=true
-      current_config[setting] = value
-      save! if persist == true
-      value
-    end
-
-    def unset setting, persist=true
-      current_config.delete(setting)
-      save! if persist == true
-    end
-
-    def current
-      Hashie::Mash.new(home_config.merge(cwd_config).merge(applied_config))
-    end
-
-    def apply_config_from_path path
-      path = Pathname(path)
-      parsed = JSON.parse(path.read) rescue {}
-      applied_config.merge!(parsed)
-      nil
-    end
-
-    def save!
-      save_home_config
-      save_cwd_config
-    end
-
-    def save_cwd_config
-      return nil unless cwd_config_path.exist?
-
-      File.open(cwd_config_path,'w+') do |fh|
-        fh.write JSON.generate(cwd_config.to_hash)
+    def method_missing(meth, *args, &block)
+      if current.respond_to?(meth) && current.key?(meth)
+        current.send(meth, *args, &block)
+      else
+        # swallow invalid method calls in production
+        super if ENV['BRIEF_DEBUG_MODE']
+        nil
       end
     end
 
-    def save_home_config
-      File.open(home_config_path,'w+') do |fh|
-        fh.write JSON.generate(home_config.to_hash)
-      end
-    end
-
-    # Applied config is configuration values passed in context
-    # usually from the cli, but also in the unit tests
-    def applied_config
-      @applied_config ||= {}
-    end
-
-    def cwd_config
-      @cwd_config ||= begin
-        (cwd_config_path.exist? rescue false) ? JSON.parse(cwd_config_path.read) : {}
-      rescue
-        {}
-      end
-    end
-
-    def home_config
-      @home_config ||= begin
-        (home_config_path.exist? rescue false) ? JSON.parse(home_config_path.read) : {}
-      rescue
-        {}
-      end
-    end
-
-    def home_folder
-      Pathname(ENV['HOME']).join('.brief')
-    end
-
-    def home_config_path
-      Pathname(ENV['HOME']).join('.brief','config.json')
-    end
-
-    def cwd_config_path
-      Pathname(Dir.pwd).join('.briefrc')
-    end
   end
 end
-

data/lib/brief/core_ext.rb

@@ -0,0 +1,11 @@
+class Hash
+  def to_mash
+    Hashie::Mash.new(self)
+  end
+end
+
+class String
+  def to_pathname
+    Pathname(self)
+  end
+end

data/lib/brief/document/content_extractor.rb

@@ -0,0 +1,33 @@
+module Brief
+  class Document::ContentExtractor
+    def initialize(model_type, document)
+      @model_type = model_type
+      @document = document
+    end
+
+    def document
+      @document
+    end
+
+    def model_class
+      Brief::Model.for_type(@model_type)
+    end
+
+    def attribute_set
+      model_class.definition.content_schema.attributes
+    end
+
+    def respond_to?(meth)
+      attribute_set.key?(meth) || super
+    end
+
+    def method_missing(meth, *args, &block)
+      if settings = attribute_set.fetch(meth, nil)
+        if settings.args.length == 1 && settings.args.first.is_a?(String)
+          selector = settings.args.first
+          document.css(selector).try(:text)
+        end
+      end
+    end
+  end
+end

data/lib/brief/document/front_matter.rb

@@ -0,0 +1,20 @@
+module Brief
+  class Document
+    module FrontMatter
+      extend ActiveSupport::Concern
+
+      def frontmatter
+        @frontmatter || load_frontmatter
+      end
+
+      protected
+
+      def load_frontmatter
+        if content =~ /^(---\s*\n.*?\n?)^(---\s*$\n?)/m
+          self.content = content[($1.size + $2.size)..-1]
+          @frontmatter = YAML.load($1).to_mash
+        end
+      end
+    end
+  end
+end

data/lib/brief/document/rendering.rb

@@ -0,0 +1,37 @@
+module Brief
+  class Document
+    module Rendering
+      extend ActiveSupport::Concern
+
+      def to_html
+        self.class.renderer.render(content)
+      end
+
+      def css(*args, &block)
+        parser.send(:css, *args, &block)
+      end
+
+      def at(*args, &block)
+        parser.send(:at, *args, &block)
+      end
+
+      def parser
+        @parser ||= Nokogiri::HTML.fragment(to_html)
+      end
+
+      module ClassMethods
+        def renderer
+          @renderer ||= begin
+                          r = ::Redcarpet::Render::HTML.new(:tables => true,
+                                            :autolink => true,
+                                            :gh_blockcode => true,
+                                            :fenced_code_blocks => true,
+                                            :footnotes => true)
+
+                          ::Redcarpet::Markdown.new(r)
+                        end
+        end
+      end
+    end
+  end
+end

data/lib/brief/document.rb

@@ -1,68 +1,73 @@
-
 module Brief
   class Document
-    attr_reader :content, :options
+    include Brief::Document::Rendering
+    include Brief::Document::FrontMatter
+
+    attr_accessor :path, :content, :frontmatter
 
-    def initialize(options)
+    def initialize(path, options={})
+      @path = Pathname(path)
       @options = options
 
-      case
-      when options.is_a?(String)
-        @content = options
-      when options.is_a?(Pathname)
-        @content = options.read
-      when options.is_a?(Hash)
-        @content = options[:path].read
+      if self.path.exist?
+        content
+        load_frontmatter
       end
+
+      self.model_class.try(:models).try(:<<, to_model) unless model_instance_registered?
     end
 
-    def write using
-      using.run_before_hooks(:write) do
-        write
-      end
+    def content
+      @content ||= path.read
     end
 
-    def publish using=nil
-      using ||= publisher
+    def extract_content(*args)
+      options = args.extract_options!
+      args    = options[:args] if options.is_a?(Hash) && options.key?(:args)
 
-      document = self
-      using.run_before_hooks(:publish) do
-        process(document)
+      case
+      when args.length == 1 && args.first.is_a?(String)
+        css(args.first).try(:text).to_s
       end
     end
 
-    def publisher
-      @publisher ||= Brief::Publisher.find(options[:publisher] || "default")
+    def data
+      frontmatter
     end
 
-    def method_missing meth, *args, &block
-      if parser.respond_to?(meth)
-        return parser.send(meth, *args, &block)
-      end
-
-      super
+    def extension
+      path.extname
     end
 
-    def checksum
-      @checksum ||= Digest::MD5.hexdigest(content)
+    def to_model
+      model_class.new(data.to_hash.merge(path: path, document: self)) if model_class
     end
 
-    def parser
-      @parser ||= Brief::Parser.new(content, checksum: checksum)
+    def model_class
+      @model_class || ((data && data.type) && Brief::Model.for_type(data.type))
     end
 
-
-    def settings
-      parser.front_matter
+    # Each model class tracks the instances of the models created
+    # and ensures that there is a 1-1 relationship between a document path
+    # and the model.
+    def model_instance_registered?
+      self.model_class && self.model_class.models.any? do |model|
+        model.path == self.path
+      end
     end
 
-    def elements
-      parser.send(:elements)
+    def respond_to?(method)
+      super || data.respond_to?(method) || data.key?(method)
     end
 
-    def tree
-      parser.send(:tree)
+    def method_missing(meth, *args, &block)
+      if data.respond_to?(meth)
+        data.send(meth, *args, &block)
+      else
+        super
+      end
     end
 
   end
 end
+

data/lib/brief/document_mapper.rb

@@ -0,0 +1,158 @@
+module Brief::DocumentMapper
+  OPERATOR_MAPPING = {
+    'equal'     => :==,
+    'eq'        => :==,
+    'neq'       => :!=,
+    'not_equal' => :!=,
+    'gt'        => :>,
+    'gte'       => :>=,
+    'in'        => :in?,
+    'include'   => :include?,
+    'lt'        => :<,
+    'lte'       => :<=
+  }
+
+  VALID_OPERATORS = OPERATOR_MAPPING.keys
+
+  class Selector
+    attr_reader :attribute, :operator
+
+    def initialize(opts = {})
+      unless Brief::DocumentMapper::VALID_OPERATORS.include?(opts[:operator])
+        raise 'Operator not supported'
+      end
+
+      @attribute, @operator = opts[:attribute], opts[:operator]
+    end
+  end
+
+  class Query
+    attr_reader :model
+
+    def initialize(model)
+      @model = model
+      @where = {}
+    end
+
+    def where(constraints_hash)
+      selector_hash = constraints_hash.reject { |key, value| !key.is_a? Selector }
+      symbol_hash = constraints_hash.reject { |key, value| key.is_a? Selector }
+      symbol_hash.each do |attribute, value|
+        selector = Selector.new(:attribute => attribute, :operator => 'equal')
+        selector_hash.update({ selector => value })
+      end
+      @where.merge! selector_hash
+      self
+    end
+
+    def order_by(field)
+      @order_by = field.is_a?(Symbol) ? {field => :asc} : field
+      self
+    end
+
+    def offset(number)
+      @offset = number
+      self
+    end
+
+    def limit(number)
+      @limit = number
+      self
+    end
+
+    def first
+      self.all.first
+    end
+
+    def last
+      self.all.last
+    end
+
+    def run_query
+      if query_is_empty?
+        select
+      else
+        model.select do |obj|
+          match = true
+
+          @where.each do |selector, value|
+            if obj.respond_to?(selector.attribute)
+              test_value = obj.send(selector.attribute)
+              operator   = OPERATOR_MAPPING[selector.operator]
+              match      = false unless test_value.send(operator, value)
+            else
+              match      = false
+            end
+          end
+
+          match
+        end
+      end
+    end
+
+    def all
+      results = run_query
+
+      if @order_by
+        order_by_attr = @order_by.keys.first
+        direction     = @order_by.values.first
+
+        results.select! do |result|
+          result.respond_to?(order_by_attr)
+        end
+
+        results.sort_by! do |result|
+          result.send(order_by_attr)
+        end
+
+        results.reverse! if direction == :desc
+      end
+
+      if @offset.present?
+        results = results.last([results.size - @offset, 0].max)
+      end
+
+      if @limit.present?
+        results = results.first(@limit)
+      end
+
+      results
+    end
+
+    def to_a
+      all
+    end
+
+    def query_is_empty?
+      @where.empty? && @limit.nil? && @order_by.nil?
+    end
+
+    def inspect
+      "Query: #{ @where.map {|k,v| "#{k.attribute} #{k.operator} #{v}" }}"
+    end
+
+    def method_missing(meth, *args, &block)
+      if all.respond_to?(meth)
+        all.send(meth, *args, &block)
+      else
+        super
+      end
+    end
+  end
+end
+
+class Symbol
+  Brief::DocumentMapper::VALID_OPERATORS.each do |operator|
+    class_eval <<-OPERATORS
+      def #{operator}
+        Brief::DocumentMapper::Selector.new(:attribute => self, :operator => '#{operator}')
+      end
+    OPERATORS
+  end
+
+  unless method_defined?(:"<=>")
+    def <=>(other)
+      self.to_s <=> other.to_s
+    end
+  end
+end

data/lib/brief/dsl.rb

@@ -0,0 +1,42 @@
+module Brief
+  module DSL
+    extend ActiveSupport::Concern
+
+    def config(options={}, &block)
+      Brief::Configuration.instance.load_options(options) unless options.nil? || options.empty?
+      Brief::Configuration.instance.instance_eval(&block) if block_given?
+    end
+
+    def define(*args, &block)
+      definition = Brief::Model::Definition.new(args.first, args.extract_options!)
+      definition.instance_eval(&block) if block_given?
+      definition.validate!
+    end
+
+    def action(identifier, options={}, &block)
+      Object.class.class_eval do
+        command "#{identifier}" do |c|
+          c.syntax = "brief #{identifier}"
+          c.description = "run the #{identifier} command"
+
+          c.action do |args, opts|
+            briefcase = Brief.case
+
+            path_args = args.select {|arg| arg.is_a?(String) && arg.match(/\.md$/) }
+
+            path_args.select! do |arg|
+              path = briefcase.repository.root.join(arg)
+              path.exist?
+            end
+
+            path_args.map! {|p| briefcase.repository.root.join(p) }
+
+            models = path_args.map {|path| Brief::Document.new(path) }.map(&:to_model)
+
+            block.call(Brief.case, models, opts)
+          end
+        end rescue nil
+      end
+    end
+  end
+end