org_mode 0.0.1

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.*.sw?
+.rvmrc
+tags

data/Gemfile

@@ -0,0 +1,26 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in org_mode.gemspec
+gemspec
+
+gem "commander"
+gem "facets"
+gem "mustache"
+
+group :development do
+  if RUBY_VERSION =~ /^1\.9/
+    gem "ruby-debug19"
+  else
+    gem "ruby-debug"
+  end
+end
+
+group :test do
+  gem "rspec", "~> 2.8.0"
+  gem "cucumber"
+  gem "timecop"
+  gem "guard-cucumber"
+  gem "popen4"
+end
+
+

data/README.mkd

@@ -0,0 +1,30 @@
+# Org-Mode file parser and writer
+
+Usin Vim for a long time, and having used e-macs for a while I got hooked on
+org-mode.  The flexible plain-tekst planning mode.
+
+Using org-mode was an eye-opener, brilliant idea but it turns out I am more of a VIM
+person.
+
+So this ruby-gem is result of this personal org-mode dissonance.
+
+## Goal
+
+Making lightweight/fast ruby org-mode executable to parse/reformat/analyse and
+report on my org-files or the one in my buffer. And following the Unix philosopy
+making a seperate process of it.
+
+## What I want
+
+* flexible parsers
+* flexible writers
+* database storage
+* org-mode website upload
+* well tested module
+* integration with vim
+* flexible reporting
+* remember mode
+
+## Code
+
+See: `lib/**/*.rb` for source and `spec/**/*.rb` for specs. Binaries not available yet.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/org-mode

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby -Ilib
+
+require 'rubygems'
+require 'commander/import'
+require 'org_mode/version'
+
+require 'org_mode/commands'
+
+program :version, OrgMode::VERSION
+program :description, 'Formats and extracts information out of org-mode files'
+program :help_formatter, :compact
+
+command :agenda do |c|
+  c.syntax = 'org-mode agenda [options]'
+  c.summary = ''
+  c.description = ''
+  c.example 'description', 'command example'
+  c.option '--some-switch', 'Some switch that does something'
+  c.when_called OrgMode::Commands::Agenda, :execute
+end
+
+command :update do |c|
+  c.syntax = 'Orgy update [options]'
+  c.summary = ''
+  c.description = ''
+  c.example 'description', 'command example'
+  c.option '--some-switch', 'Some switch that does something'
+  c.action do |args, options|
+    # Do something or c.when_called Orgy::Commands::Update
+  end
+end
+

data/features/cmdline_agenda.feature

@@ -0,0 +1,34 @@
+Feature: agenda
+  org-mode tools should extract meaningfull information
+  out of the parsed org-mode files and present
+  it in a nicely correct format.
+
+  Scenario: should present meaningfull agenda information
+    Given date is "1-1-2012 15:00"
+    And we have an org-file with the following content
+      """
+      * TODO Scheduled task <1-1-2012 Wed 15:15>
+      """
+    When the script is executed on the org-file
+    When the script is called with "agenda"
+    Then the output should be
+      """
+      Agenda ()
+        2012-01-01
+          TODO Scheduled task 
+      """
+
+  # @focus
+  # Scenario: should limit restults in a day view
+  #   Given date is "1-1-2012 15:00"
+  #   And we have an org-file with the following content
+  #     """
+  #     * TODO Todays task <1-1-2012 Wed 15:15>
+  #     * TODO Tommorrows task <2-1-2012 Wed 15:15>
+  #     """
+  #   When the script is called with "agenda today"
+  #   Then the output should be
+  #     """
+  #     Todays activities:
+  #       TODO Todays task
+  #     """

data/features/cmdline_handles_errors_cracefully.feature

@@ -0,0 +1,10 @@
+Feature: Handles errors gracefully
+  Incomplete information or missing non-existing
+  files should be reported.
+
+  Scenario: non-existing file
+    When the script is called with "agenda /tmp/non-existent.org"
+    Then the output should be
+    """
+    Encountered a little problem: No such file or directory - /tmp/non-existent.org
+    """

data/features/cmdline_noparams.feature

@@ -0,0 +1,11 @@
+Feature: noparams or reformat
+  Whenever the org-mode script is run without params
+  it should just display help
+
+  Scenario: script with no params should display help
+    When the script is called with "" should fail
+    Then the error should be
+      """
+      invalid command. Use --help for more information
+      """
+

data/features/cmdline_todos.feature

@@ -0,0 +1,5 @@
+Feature: todos
+  The org-mode tools should lists relevant
+  todos in a clear consice fomat.
+  It is also easy to extract todo's based on criteria
+  such as tags.

data/features/steps.rb

@@ -0,0 +1,35 @@
+require 'timecop'
+
+Given /^we have an org\-file with the following content$/ do |string|
+  @org_file = Tempfile.new('org_file')
+  @org_file.write(string)
+  @org_file.flush
+end
+
+When /^the script is called with "([^"]*)"( should fail)?$/ do |argv, should_fail|
+  org_mode_args = []
+  org_mode_args << argv if argv
+  org_mode_args << @org_file.path if @org_file
+
+  begin
+    @stdout, = org_mode_script(*org_mode_args)
+  rescue OrgModeScriptError => script_error
+    raise unless should_fail
+    @script_error = script_error
+  end
+end
+
+Given /^date is "([^"]*)"$/ do |date_string|
+  Timecop.freeze(Date.parse(date_string))
+end
+
+When /^the script is executed on the org-file$/ do
+  @stdout, = org_mode_script(:agenda, @org_file.path)
+end
+
+Then /^the output should be$/ do |string|
+  @stdout.should == string
+end
+Then /^the error should be$/ do |string|
+  @script_error.stderr.chomp.should == string
+end

data/features/support/org_mode_script.rb

@@ -0,0 +1,53 @@
+require 'tempfile'
+require 'ruby-debug'
+require 'popen4'
+
+class OrgModeScriptError < StandardError;
+  attr_accessor :stdout, :stderr, :status, :cmd
+
+  def initialize(stdout, stderr, status, cmd)
+    @stdout = stdout
+    @stderr = stderr
+    @status = status
+    @cmd = cmd
+    super("Failed command: #{cmd}")
+  end
+  
+  def message
+    <<-eom.gsub(/^\s{4}/, '')
+      Failed command: #{cmd}
+      Stderr:
+        #{@stderr.empty? ? 'None' : @stderr}
+      Stdout:
+        #{@stdout.empty? ? 'None' : @stdout}
+    eom
+  end
+
+end
+
+# Private: runs org-mode binary and captures output
+#
+# builds command out of parameters and calls capturing
+# stdout/stderr and the exit status
+#
+# Raises an OrgModeScriptError when status is not success
+#   OrgModeScriptError contains all the information on the command
+#
+# Returns stdout as String, stderr as String, status as Process::Status
+def org_mode_script(cmd, *params)
+
+  # build command
+  cmd = %[bin/org-mode #{cmd} #{params * ' '}]
+
+  stdout, stderr = [ nil,nil ]
+  status = POpen4.popen4(cmd) do |pout,perr|
+    stdout = pout.read
+    stderr = perr.read
+  end
+
+  unless status.success?
+    raise OrgModeScriptError.new(stdout, stderr, status, cmd)
+  end
+
+  return [stdout.chomp, stderr, status]
+end

data/lib/core_ext/string.rb

@@ -0,0 +1,5 @@
+class String
+  def strip_indent(count)
+    self.gsub(/^\s{#{count}}/,'')
+  end
+end

data/lib/org_mode/commands/agenda.rb

@@ -0,0 +1,39 @@
+require 'org_mode/parser'
+require 'org_mode/loader'
+require 'org_mode/reporters/agenda'
+
+require 'core_ext/string'
+require 'mustache'
+
+module OrgMode::Commands
+  class Agenda
+    # Private: executes the agenda command
+    # parses all the files
+    #
+    # args - list of filenames
+    # options - switches set by the app
+    #
+    # Returns the restult to stdout
+    def execute(args, options)
+
+      file_collection = OrgMode::Loader.load_and_parse_files(*args)
+      agenda_reporter = OrgMode::Reporters::Agenda.new(file_collection)
+
+      tmpl_vars = {}
+      tmpl_vars[:noi_per_date] = agenda_reporter.open_nodes_grouped_by_day
+
+      puts Mustache.render <<-eos.strip_indent(8), tmpl_vars
+        Agenda ()
+        {{#noi_per_date}}
+          {{date}}
+          {{#nodes}}
+            {{todo_state}}{{title}}
+          {{/nodes}}
+          {{/noi_per_date}}
+      eos
+
+    rescue SystemCallError => e
+      puts "Encountered a little problem: #{e}"
+    end
+  end
+end

data/lib/org_mode/commands/update.rb

@@ -0,0 +1,4 @@
+module OrgMode::Commands
+  class Update
+  end
+end

data/lib/org_mode/commands.rb

@@ -0,0 +1,7 @@
+module OrgMode
+  module Commands
+  end
+end
+
+require 'org_mode/commands/agenda'
+require 'org_mode/commands/update'

data/lib/org_mode/loader.rb

@@ -0,0 +1,17 @@
+class OrgMode::Loader
+  # Public: loads and parses multiple files
+  #
+  # Returns OrgMode::FileCollection
+  def self.load_and_parse_files *paths
+    org_mode_files = paths.map {|f| load_and_parse_file(f) } 
+    OrgMode::FileCollection.new(org_mode_files)
+  end
+
+  # Public: loads and parse a file
+  #
+  # Returns OrgMode::File
+  def self.load_and_parse_file path
+    f = File.open(path)
+    OrgMode::FileParser.parse(f.read)
+  end
+end

data/lib/org_mode/parser.rb

@@ -0,0 +1,137 @@
+# Public: Org File format parser
+#
+# A simple regexp based parser for orgfiles. Works by simply dividng
+# the file in beginning, nodes, and ending. After this it will
+# parse the individual nodes extracting remaining detailed information.
+#
+# Parser is decoupled from object model to make it easy to write updated
+# parsers or use a database to serialize an org-mode file out of.
+require 'org_mode'
+require 'date'
+
+module OrgMode
+  class FileParser
+    RxNodeTitle = %r{ 
+      ^   # beginning of line
+      (
+        \*+ # multiple stars 
+        \s+ # one or more whitespace
+        .*  # anything
+      )
+      $   # untill _end of line
+    }xs
+
+    class << self
+
+      # Public: parses buffer into nodes and
+      # collects there in a OrgMode::File object
+      #
+      # Returns OrgMode::File object containing all
+      # information of the file. 
+      def parse(buffer)
+        b, nodes, e =  parse_buffer(buffer)
+
+        parent_stack = []
+        nodes.map! do |title, content| 
+          node = NodeParser.parse(title,content) 
+          node.parent = parent_stack[node.stars - 1]
+          if node.parent
+            node.parent.children << node
+          end
+          parent_stack[node.stars] = node
+        end
+        return File.new(b,nodes,e)
+      end
+
+      def parse_buffer(buffer)
+        beginning_of_file, nodes, ending_of_file =
+          parse_into_tokens(buffer)
+      end
+
+
+      # Private: splits buffer into different parts
+      #   First part is beginning of file
+      #   Second part are the nodetitles in combination
+      #   with the content
+      #   Third part is the ending of the file
+      # 
+      # buffer - org mode data
+      #
+      # Returns beginning_of_file, nodes, and ending
+      #   if beginning is not present and empy string is 
+      #   returned. This function will never return nil
+      # 
+      def parse_into_tokens buffer
+        tokens = buffer.split(RxNodeTitle).map(&:rstrip)
+        beginning_of_file = tokens.shift || ''
+
+        nodes = []
+        while !tokens.empty?
+          nodes << Array.new(2) { tokens.shift || '' }
+        end
+
+        nodes.map! { |t,c| [t,c[1..-1] || ''] }
+
+        [ beginning_of_file, nodes, "" ]
+      end
+    end
+  end
+
+  class NodeParser
+
+    class << self
+
+      # Public: Parses a node in the org-mode file-format
+      # 
+      # title - a org-mode title, can contain date, todo statusses, tags
+      #         everything specified in the org-mod file format
+      # content - the content block, which can also contain org-mode format
+      #
+      # Return a OrgMode::Node containing all parsable information
+      def parse(title,content)
+        node = OrgMode::Node.new
+        parse_title(node, title)
+        parse_extract_dates(node)
+        parse_content(node, content)
+        node
+      end
+
+      private
+
+      def parse_title(node,title)
+        matches = title.match( /^(\*+)\s+(TODO|DONE)?(.*)$/ )
+        node.stars      = matches[1].length
+        node.todo_state = matches[2]
+        node.title      = matches[3]
+        #node.indent     = node.stars + 1
+      end
+
+      RxDateRegexp = /<(\d+-\d+-\d+)(?:\s(?:\w{3})?(?:\s(\d+:\d+))?)(?:-(\d+:\d+))?>/
+        def parse_extract_dates(node)
+          _, extracted_date, start_time, end_time = node.title.match(RxDateRegexp).to_a
+          node.title = node.title.gsub(RxDateRegexp, '') 
+
+          if extracted_date
+            node.date_start_time = DateTime.parse("#{extracted_date} #{start_time}")
+            node.date_end_time = DateTime.parse("#{extracted_date} #{end_time}")
+          end
+        end
+
+      RxEmptyLine = /^\s*$/
+        def parse_content(node,content)
+          return unless content
+
+          minimum_indent = ( content.lines.map {|l| l =~ /\S/ }.reject(&:nil?) + [node.indent] ).min
+          content.gsub!(/^\s{#{minimum_indent}}/m, '')
+
+            # remove empty lines at beginning and ending
+            node.content = content.lines.
+            drop_while {|e| e =~ RxEmptyLine}.
+            reverse.
+            drop_while {|e| e =~ RxEmptyLine}.
+            reverse.
+            join
+        end
+    end
+  end
+end

data/lib/org_mode/reporters/agenda.rb

@@ -0,0 +1,44 @@
+require 'facets/to_hash'
+
+module OrgMode
+  module Reporters
+    class Agenda
+      attr_accessor :file_collection
+      def initialize(file_collection)
+        @file_collection = file_collection 
+      end
+
+      # Public: returns open nodes grouped by day
+      # ordered by date
+      #
+      # Returns an Array of Hash-es like 
+      # [{:date => '%Y-%m-%d', :nodes => [{ .. }]}]
+      # ready to be used by fe Mustache
+      def open_nodes_grouped_by_day
+        # Get all nodes from all files
+        # extract scheduled items which are not done
+        # discard all DONE items
+        nodes_of_interest = file_collection.scheduled_nodes.select(&:open?)
+
+        # group them by date
+        noi_per_day = nodes_of_interest.group_by { |noi| noi.date.strftime('%Y-%m-%d') }
+       
+        # build a nice orderd struct
+        noi_per_day.keys.sort.map do |date|
+          { :date => date, :nodes => noi_per_day[date].map { |n| node_to_hash(n) } }
+        end
+      end
+
+      private
+
+    def node_to_hash(node)
+      rv = [:title, :content, :todo_state, :date, :stars].
+        map { |k| [ k, node.send(k) ] }.to_h
+
+      rv[:date] = rv[:date].strftime('%Y-%m-%d %H:%M') if rv[:date]
+      rv
+    end
+
+    end
+  end
+end

data/lib/org_mode/version.rb

@@ -0,0 +1,3 @@
+module OrgMode
+  VERSION = "0.0.1"
+end

data/lib/org_mode.rb

@@ -0,0 +1,87 @@
+# Public: Domain objects
+# describing the elements of an org-mod file
+#
+# OrgMode::File encapsulates the org file, with all its settings
+# customizations, code blocks, TODO statusses.
+#
+# This domain model will be build using one of the parsers which
+# you can find somewhere in lib/org_mode/parser*
+#
+# Writing this domain-model to a file can be done using
+# one of the Writes in lib/org_mode/writers/*
+#
+require "org_mode/version"
+
+module OrgMode
+
+
+  class Node
+    attr_accessor :title, :content, :stars, :date_start_time, :date_end_time, :todo_state
+    attr_accessor :parent, :children
+
+    def initialize
+      @parent = nil
+      @children = []
+    end
+
+    alias :date :date_start_time
+    alias :date= :date_start_time=
+
+    def indent 
+      stars + 1
+    end 
+
+    def root_node?
+      stars == 1
+    end
+
+    def scheduled?
+      !date.nil?
+    end
+
+    def open?
+      not done?
+    end
+
+    def done?
+      todo_state == 'DONE'
+    end
+
+  end
+
+  module FileInterface
+    def root_nodes
+      nodes.select(&:root_node?)
+    end
+
+    def scheduled_nodes
+      nodes.select(&:scheduled?)
+    end
+  end
+
+  class File
+    attr_accessor :header, :nodes, :footer
+
+    include FileInterface
+
+    def initialize(header, nodes, footer)
+      @header = header
+      @footer = footer
+      @nodes = nodes
+    end
+  end
+
+  class FileCollection
+    attr_accessor :files
+
+    include FileInterface
+
+    def initialize(files)
+      @files = files 
+    end
+
+    def nodes
+      files.map(&:nodes).flatten
+    end
+  end
+end

data/org_mode.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "org_mode/version"
+
+Gem::Specification.new do |s|
+  s.name        = "org_mode"
+  s.version     = OrgMode::VERSION
+  s.authors     = ["Boy Maas"]
+  s.email       = ["boy.maas@gmail.com"]
+  s.homepage    = "https://github.com/boymaas/orgy"
+  s.summary     = %q{Parses and does all kinds of tricks with org-mode files}
+  s.description = %q{Org-mode parser, presenters, and reformatters}
+
+  s.rubyforge_project = "org_mode"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  s.add_development_dependency "rake"
+  # s.add_runtime_dependency "rest-client"
+  s.add_runtime_dependency "commander"
+  s.add_runtime_dependency "facets"
+  s.add_runtime_dependency "mustache"
+end

data/spec/data/org-file-01-simple-node-structure.org

@@ -0,0 +1,12 @@
+* Main
+** FirstChildMain
+** SecondChildMain
+*** FirstChildSecondChildMain
+* SecondMain
+** FirstChildMain
+*** SecondChildMain
+** FirstChildSecondChildMain
+* ThirdMain
+** FirstChildMain
+*** FirstChildFirstChildMain
+**** FirstChildFirstChildFirstChildMain