working_class 0.1.1

data/README.md

@@ -0,0 +1,195 @@
+# WorkingClass
+
+WorkingClass is an human readable syntax to write tasklists.
+Besides being easy to read it's fully parseable, so you can work with the tasks
+in Ruby.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'working_class'
+```
+
+And then execute:
+
+```sh
+$ bundle
+```
+
+Or install it yourself as:
+
+```sh
+$ gem install working_class
+```
+
+## Usage
+
+### The Syntax
+
+Keep in mind that all dates are formatted like this: `DD.MM.YYYY` or `D.M.YY`
+
+```
+Tasklist Name
+---
+[ ] My first task
+[X] A finished task
+[ ]{1.1.15} A task with a due date
+[ ]{1.1.15}(31.1.15 12:00) A task with a date and a reminder
+[ ]{1.1.15}(-1 12:00) A task with a date and a »relative« reminder
+[ ]{1.1.15}(12:00) A task that will remind me at 12:00 1.1.15
+```
+
+You see it's pretty easy to write tasks like this.
+
+At the moment the order of date and reminder is mandatory.
+
+So you **can't** write:
+
+```
+My Tasklist
+---
+[ ](REMINDER){DATE} My Task
+```
+
+
+#### Tasklist Names
+
+A tasklist name is written like this:
+
+The `---` is important, don't forget it.
+
+Every tasklist should have a name.
+
+```
+Tasklist Name
+---
+…
+```
+
+#### Unfinished Tasks
+
+Both tasks are equal, they are both not finished.
+
+We recommend the `[ ]`, it looks much nicer.
+
+```
+Shopping List
+---
+[ ] Jeans
+[] T-Shirts
+```
+
+#### Finished Tasks
+
+```
+Groceries List
+---
+[X] Milk
+[x] Bread
+```
+
+To write a finished task you have to write a `[X]` or `[x]`. It's not important
+whether you write a small x or a capital X, both characters are recognized as
+a finished task.
+
+
+#### Tasks with a Date
+
+It doesn't matter if you write your dates DD.MM.YY or D.M.YY or DD.MM.YYYY
+WorkingClass accepts all of those formats, as long as it is a valid date.
+
+
+```
+The Party List
+---
+[X]{6.2.2015} Birthday Party
+[X]{13.2.15} Another Birthday Party
+```
+
+#### Tasks with a Reminder
+
+Every task can have a reminder.
+You have several options when adding a reminder.
+
+All times are 24h.
+
+You can write a full date without a time and the parser will add the default
+time (9:00) automatically.
+
+```
+An even more awesome Party List
+---
+[ ](31.1.15) This time of year
+```
+
+If you already specified a date for the task you can use a relative reminder
+by writing `-2`, this specifies that you want to be reminded 2 days earlier.
+The parser will add the default time, if you didn't add one.
+
+```
+The after party
+---
+[ ]{2.1.15}(-2) You will have to clean up everthing.
+```
+
+**Important:** This only works if your task has already a date.
+
+This will not work:
+
+```
+The after party
+---
+[ ](-2) You will have to clean up everthing.
+```
+
+So enough of that, what about the times. You can easily add a time to your
+reminder
+
+```
+My Finals
+---
+[ ]{26.1.15}(15:00) English
+```
+
+If you don't specify a relative or absolute date you will be reminded at 15:00
+on the same day.
+
+
+You can also combine absolute or relative dates with a time
+
+```
+My Finals
+---
+[ ]{26.1.15}(24.1.15 9:00) Don't panic.
+[ ]{26.1.15}(-1 15:00) English
+```
+
+### The Parser
+
+Check out the [full documentation](http://www.rubydoc.info/github/TimKaechele/WorkingClass/master)
+
+```ruby
+require 'working_class'
+
+string = """
+My Finals
+---
+[ ]{26.1.15}(15:00) English
+"""
+
+WorkingClass.load(string) # => WorkingClass::Tasklist
+
+# or if you have a file
+WorkingClass.load_file('./examples/example_1.txt') # => WorkingClass::Tasklist
+
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/TimKaechele/workingclass/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+
+require "rake/testtask"
+
+Rake::TestTask.new do |task|
+  task.libs << %w(test lib)
+  task.pattern = "test/*_test.rb"
+end
+
+task :default => :test
+

data/lib/working_class.rb

@@ -0,0 +1,29 @@
+require 'working_class/version'
+require 'working_class/parser'
+require 'working_class/task'
+require 'working_class/tasklist'
+
+# WorkingClass Module
+#
+module WorkingClass
+
+  # Loads the file from the path and returns a Tasklist
+  #
+  # @param path [String] the filepath
+  # @return [WorkingClass::Tasklist] the parsed Tasklist
+  #
+  def self.load_file(path)
+    string = File.open(path, 'r').read()
+    self.load(string)
+  end
+
+  # Parses the given string and returns a Tasklist
+  #
+  # @param string [String] the WorkingClass tasklist syntax string
+  # @return [WorkingClass::Tasklist] the parsed Tasklist
+  #
+  def self.load(string)
+    Parser.new(string).to_tasklist
+  end
+
+end

data/lib/working_class/parser.rb

@@ -0,0 +1,165 @@
+require 'date'
+
+module WorkingClass
+  # The actual syntax parser
+  #
+  class Parser
+
+    # Initializes a new Parser object with a given WorkingClass syntax string
+    #
+    # @param string [String] the raw string with the WorkingClass syntax
+    # @return [WorkingClass::Parser] a parser instance
+    #
+    def initialize(string)
+      @raw_string = string
+      @date_regex = /(?:\d{1,2}\.){2}\d{2,4}/
+      @time_regex = /\d{1,2}:\d{1,2}/
+    end
+
+    # Parses the syntax and returns an Hash with the result
+    #
+    # @return [Hash] a Hash representation of the parsed tasklist
+    #
+    def to_h
+      {
+        name: tasklist_name,
+        tasks_count: tasks.length,
+        tasks: tasks
+      }
+    end
+
+    # Parses the syntax and returns a WorkingClass::Tasklist instance
+    #
+    # @return [WorkingClass::Tasklist] a Tasklist instance of the parsed tasklist
+    #
+    def to_tasklist
+      tasks = Array.new
+      raw = self.to_h
+      raw[:tasks].each do |t|
+        task = Task.new(t[:name], t)
+        tasks << task
+      end
+      Tasklist.new raw[:name], tasks
+    end
+
+    private
+      def tasklist_name_regex
+        /(.*)\n---/
+      end
+
+      def task_regex
+        /\[(.*)\] *(?:\{(.*)\})? *(?:\((.*)\)){0,1} *(.*)/
+      end
+
+      def tasklist_name
+        @raw_string.match(tasklist_name_regex).captures.first
+      end
+
+      def tasks
+        tasks = []
+        @raw_string.scan(task_regex).each do |match|
+          task = Hash.new
+          task[:is_finished] = extract_is_finished(match[0])
+          task[:date] = extract_date(match[1])
+          task[:reminder] = extract_reminder(task[:date], match[2])
+          task[:name] = extract_name(match[3])
+          tasks << task
+        end
+        tasks
+      end
+
+      def extract_is_finished(match)
+        match = match.strip
+        if match == "x" or match == "X"
+          true
+        else
+          false
+        end
+      end
+
+      def extract_date(match)
+        if match.nil?
+          return nil
+        end
+
+        if match.scan(@date_regex)
+          # @todo rescue the right exception
+          begin
+            normalize_date(match)
+          rescue
+            nil
+          end
+        else
+          nil
+        end
+      end
+
+
+      def extract_name(match)
+        if !match.nil?
+          match.strip
+        else
+          ""
+        end
+      end
+
+      def normalize_date(date_string)
+        parts = date_string.split(".")
+        if parts[2].length == 2
+          parts[2] = "20" + parts[2]
+        end
+        parts = parts.map { |p| p.to_i }
+        Date.new(parts[2], parts[1], parts[0])
+      end
+
+      # Shame Shame
+      # @todo REFACTOR!!!!!1eleven!1
+      def extract_reminder(task_date, match)
+        if match.nil?
+          return nil
+        end
+
+        if match.empty? and !task_date.nil?
+          return DateTime.parse(task_date.to_s + " 9:00")
+        elsif match.empty? and task_date.nil?
+          return nil
+        end
+
+        date = nil
+        time = nil
+
+        absolute_date = match.scan(/(#{@date_regex})/)
+        relative_date = match.scan(/(-\d{1,2})/)
+        match_time    = match.scan(/(#{@time_regex})/)
+
+        if absolute_date.empty? and (!relative_date.empty? and !task_date.nil?)
+          date = task_date + relative_date.flatten.first.to_i
+        elsif !absolute_date.empty?
+          # @todo rescue the right exception
+          begin
+            date = normalize_date(absolute_date.flatten.first)
+          rescue
+            date = nil
+          end
+        end
+
+        if !match_time.empty?
+          time = match_time
+        end
+
+        if !date.nil? and !time.nil?
+          DateTime.parse(date.to_s + " #{time}")
+        elsif (date.nil? and !task_date.nil?) and !time.nil?
+          DateTime.parse(task_date.to_s + " #{time}")
+        elsif !date.nil? and time.nil?
+          DateTime.parse(date.to_s + " 9:00")
+        else
+          return nil
+        end
+
+      end
+
+
+  end
+end
+

data/lib/working_class/task.rb

@@ -0,0 +1,82 @@
+module WorkingClass
+
+  # A basic represantation of a Task
+  #
+  # @attr_reader name [String] the task name
+  # @attr_reader is_finished [Boolean] true if the task is finished
+  # @attr_reader date [Date] the day the task is due
+  # @attr_reader reminder [DateTime] a DateTime with a reminder
+  class Task
+
+    attr_reader :name
+    attr_reader :date
+    attr_reader :reminder
+    attr_reader :is_finished
+
+    alias :is_finished? :is_finished
+    alias :finished? :is_finished
+
+    # Initializes a new task object with a name, and options
+    #
+    # @param name [String] the task name
+    # @param options [Hash] an options hash
+    #
+    # @option options [Boolean] :is_finished (false) true if the task is finished
+    # @option options [Date] :date (nil) the date when the task is due
+    # @option options [DateTime] :reminder (nil )a DateTime with a reminder
+    #
+    def initialize name, options = {}
+      options = {is_finished: false, date: nil, reminder: nil}.merge(options)
+      @name = name
+      @is_finished = options[:is_finished]
+      @date = options[:date]
+      @reminder = options[:reminder]
+    end
+
+    # Returns true if the task is upcoming
+    #
+    # A Task without a date is always upcoming.
+    # @todo add example
+    #
+    # A finished task is never upcoming.
+    # @todo add example
+    #
+    # @return [Boolean] true if the task is upcoming
+    def is_upcoming
+      if @is_finished
+        false
+      elsif !@date.nil?
+        Date.today <= @date
+      else
+        true
+      end
+    end
+
+    alias :is_upcoming? :is_upcoming
+    alias :upcoming? :is_upcoming
+
+    # Returns true if the task is due tomorrow
+    #
+    # A Task without a date is always due tomorrow.
+    # @todo add example
+    #
+    # A finished task is never due tomorrow.
+    # @todo add example
+    #
+    # @return [Boolean] true if the task is due tomorrow
+    def is_tomorrow
+      if @is_finished
+        false
+      elsif date.nil?
+        true
+      else
+        Date.today + 1 == @date
+      end
+    end
+
+    alias :is_tomorrow? :is_tomorrow
+    alias :tomorrow? :is_tomorrow
+
+
+  end
+end