chronograph 0.0.1

data/.autotest

@@ -0,0 +1,23 @@
+# -*- ruby -*-
+
+require 'autotest/restart'
+
+# Autotest.add_hook :initialize do |at|
+#   at.extra_files << "../some/external/dependency.rb"
+#
+#   at.libs << ":../some/external"
+#
+#   at.add_exception 'vendor'
+#
+#   at.add_mapping(/dependency.rb/) do |f, _|
+#     at.files_matching(/test_.*rb$/)
+#   end
+#
+#   %w(TestA TestB).each do |klass|
+#     at.extra_class_map[klass] = "test/test_misc.rb"
+#   end
+# end
+
+# Autotest.add_hook :run_command do |at|
+#   system "rake build"
+# end

data/History.txt

@@ -0,0 +1,4 @@
+=== 0.0.1 / 2010-11-08
+
+* First release, gem works, most planned features added
+

data/Manifest.txt

@@ -0,0 +1,15 @@
+.autotest
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/chronograph.rb
+lib/chronograph/dsl.rb
+lib/chronograph/event.rb
+lib/chronograph/person.rb
+lib/chronograph/timeline.rb
+test/test_timeline.rb
+test/test_dsl.rb
+test/test_person.rb
+test/test_event.rb
+examples/programing_example.rb

data/README.txt

@@ -0,0 +1,67 @@
+= chronograph
+
+* http://geeklob.wordpress.com
+
+== DESCRIPTION:
+
+Chronograph is a Ruby DSL for making timelines
+
+== FEATURES/PROBLEMS:
+
+* Intuitive syntax
+* Code easy to understand, good example DSL
+* Multiple output formats
+
+== SYNOPSIS:
+
+    require 'chronograph'
+
+    x = Chronograph::Timeline.new do
+        event "Chronograph released on github" Date.new(2010, 11, 7), "Chronograph is released  in a github repo"
+    end
+
+You can then get the timeline in html table format or in plain text.
+
+For a better example, see example/ directory.
+
+== REQUIREMENTS:
+
+* kramdown
+
+== INSTALL:
+
+* gem install indigo747-chronograph # Warning, hasn't been tested
+
+== DEVELOPERS:
+
+After checking out the source, run:
+
+  $ rake newb
+
+This task will install any missing dependencies, run the tests/specs,
+and generate the RDoc.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2010 FIX
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,12 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+
+Hoe.spec 'chronograph' do
+    developer('Indigo Casson', 'atamiser@gmail.com')
+
+  # self.rubyforge_name = 'chronographx' # if different than 'chronograph'
+end
+
+# vim: syntax=ruby

data/examples/programing_example.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/ruby
+# Sorry to java lovers. Interestingly, I like java, but I needed a subject
+# matter, and the French revolution didn't seem like a good one.
+
+require 'rubygems'
+require 'chronograph' # This is the all important line
+
+t = Chronograph::Timeline.new do
+
+    # Groups affect html tags, but not, as of now, affect plain text
+    group :ruby do
+        # Group related events and people together. Whenever you recurse
+        # like this, you get the same DSL. Note that while this looks
+        # recursive, the recursivity of the data is not saved.
+        person "Mr. Ruby", 1654, 2010, "He was awesome" do
+            # This event could be here, it could be in the
+            # root of the block, or in one further in. It 
+            # doesn't matter
+            event "Mr. Ruby leaves Japan", 2000, "It was _easy_"
+
+            # People, long_events, and wars are handled in 
+            # essentially the same way, but with different
+            # wording for the start and end events.
+            war "War against Java", 2005, 2007, "It was needed" do
+
+                # When you need a more precise date, you can use the default
+                # constructor. When you just need a year, just use the year.
+                # In this case, you could just use 2005, though it will show up
+                # as January 1st of 2005.
+                event "Battle of the MRI", Date.new(2005, 5, 6), "Mr. Ruby almost lost"
+                # These events get added to the general event list. All events
+                # do regardless of where they are defined. Niether location nor
+                # order of the definition matters.
+                event "Battle of the JVM", Date.new(2005, 10, 31), "This was one scary halloween for Javaland"
+            end
+        end
+    end
+                        
+    group :java do
+        # This is the stupid and redundant way of doing things.
+        # Can you guess how we could improve this?
+        event "Javaland founded", Date.new(1990), "1000s die"
+
+        event "Clojure", 2000, "people are intrigued"
+
+    end
+                                
+                                
+    # This represents today.
+    today
+end
+
+# This first prints out the html table, and then the plain text version
+puts t.get_html_table
+puts t.get_text
+

data/lib/chronograph/dsl.rb

@@ -0,0 +1,64 @@
+require 'chronograph/event'
+require 'chronograph/person'
+
+module Chronograph
+    class EventDSL
+        attr_accessor :events, :people
+        def initialize()
+            @events = []
+            @people = []
+        end
+
+
+        def event(name, date, desc)
+            date = parse_date date
+            @events << Event.new(name, date, desc)
+        end
+    
+        def today
+            event "Today", Date.today, "this day"
+        end
+    
+        def person(name, birth, death, desc, &block)
+            birth = parse_date birth
+            death = parse_date death
+            t = EventDSL.new
+            t.instance_eval(&block) if block != nil
+            
+            @people << Person.new(name, birth, death, desc, *(t.events + t.people.map { |x| x.events })) # TODO: this sort of combines the events and the people. Problem?
+        end
+
+        def long_event(name, birth, death, desc, &block)
+            birth = parse_date birth
+            death = parse_date death
+            t = EventDSL.new
+            t.instance_eval(&block) if block != nil
+
+            @people << LongEvent.new(name, birth, death, desc, *(t.events + t.people.map { |x| x.events }))
+        end
+
+        def war(name, birth, death, desc, &block)
+            birth = parse_date birth
+            death = parse_date death
+            t = EventDSL.new
+            t.instance_eval(&block) if block != nil
+
+            @people << War.new(name, birth, death, desc, *(t.events + t.people.map { |x| x.events }))
+        end
+
+        def parse_date x
+            x.is_a?(Integer) ? Date.new(x) : x
+        end
+
+        def group name, &block
+            events = []
+            t = EventDSL.new
+            t.instance_eval(&block) if block != nil
+            events << t.events
+            events << t.people.map { |x| x.events}
+            events.flatten!
+            events.each { |x| x.group = name}
+            @events << events.flatten
+        end
+    end
+end

data/lib/chronograph/event.rb

@@ -0,0 +1,29 @@
+require "kramdown"
+
+module Chronograph
+    class Event
+        attr_accessor :name, :date, :desc, :group
+        def initialize(name, date, desc, group=:default)
+            raise TypeError.new("date must be a date") unless date.is_a? Date
+            raise TypeError.new("name has to be a name or symbol") unless name.is_a?(String) || name.is_a?(Symbol)
+            raise TypeError.new("desc must be a string") unless desc.is_a? String
+            raise TypeError.new("group has to be a name or symbol") unless group.is_a?(String) || group.is_a?(Symbol)
+            @name = name
+            @date = date
+            @desc = desc
+            @group = group
+        end
+
+        def to_table_html
+            "<tr class=\"#{@group}\">"+
+               "<td class=\"date\">#{@date}</td>"+
+               "<td class=\"name\">#{@name}</td>"+
+               "<td class=\"desc\">#{Kramdown::Document.new(@desc).to_html}</td>"+
+               "</tr>"
+        end
+    end
+end
+
+def parse_date x
+    x.is_a?(Integer) ? Date.new(x) : x
+end

data/lib/chronograph/person.rb

@@ -0,0 +1,44 @@
+module Chronograph
+    class Person < Struct.new(:name, :birth, :death, :desc, :events)
+        attr_reader :name, :birth, :death, :desc
+        def initialize(name, birth, death, desc, *events)
+            raise TypeError.new("name has to be a name or symbol") unless name.is_a?(String) || name.is_a?(Symbol)
+            raise TypeError.new("birth and death must be a date") unless birth.is_a?(Date) && death.is_a?(Date)
+            
+            raise TypeError.new("desc must be a string") unless desc.is_a? String
+            
+            @name = name
+            @birth = birth
+            @death = death
+            @desc = desc
+            @events = events
+        end
+        
+        def events
+            [begining_event, ending_event, @events].flatten
+        end
+
+        def begining_event
+            Event.new("Birth of #{name}", birth, "#{name} is born. #{@desc}")
+        end
+
+        def ending_event
+             Event.new("Death of #{name}", death, "#{name} dies. #{@desc}")
+        end
+
+
+    end
+
+    class LongEvent < Person
+        def begining_event                               
+            Event.new("Beginning of #{name}", birth, "#{name} begins. #{@desc}")
+        end
+
+        def ending_event
+            Event.new("End of #{name}", death, "#{name} ends. #{@desc}")
+        end
+    end
+
+    
+    class War < LongEvent; end
+end

data/lib/chronograph/timeline.rb

@@ -0,0 +1,56 @@
+
+require 'chronograph/dsl'
+
+module Chronograph
+	class Timeline
+        include Enumerable
+
+		def initialize(&block)
+			@people = []
+			@events = []
+
+            t = EventDSL.new
+            t.instance_eval(&block)
+            @people << t.people
+            @events << t.events
+		end
+
+        def add &block
+            t = EventDSL.new
+            t.instance_eval(&block)
+            @people << t.people
+            @event << t.events
+        end
+
+        def each(&block)
+            consolidate.each(&block)
+        end
+
+		def event(name, date, desc)
+			@events << Event.new(name, date, desc)
+		end
+		
+		def today
+			event "Today", Date.today, "this day"
+		end
+
+		def consolidate
+			t = []
+			t << @events << @people.flatten.map { |x| x.events }
+			return t.flatten.sort { |a, b| a.date <=> b.date }
+		end
+		
+		def get_text
+			consolidate.map { |x| "#{x.date}: #{x.name}, #{x.desc}" }.join("\n")
+		end
+
+		def get_html_table
+#            warn "Warning, get_html_table has not tested"
+			r = "<table>"
+			consolidate.each do |x|
+                r += x.to_table_html
+			end
+			r += "</table>"
+		end
+	end
+end

data/lib/chronograph.rb

@@ -0,0 +1,12 @@
+libdir = File.dirname(__FILE__)
+$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
+
+
+require 'date'
+require 'chronograph/timeline'
+
+
+module Chronograph
+    VERSION = "0.0.1"
+end
+

data/test/test_dsl.rb

@@ -0,0 +1,40 @@
+require "test/unit"
+require "chronograph"
+
+module Chronograph
+    class TestDSL < Test::Unit::TestCase
+      def test_sanity
+          assert_nothing_raised(Exception) { t = EventDSL.new }
+      end
+
+      def test_event
+          name, date, desc = "test", Date.today, "test_cool"
+          t = EventDSL.new
+          t.event name, date, desc
+          x = t.events[0]
+          assert(x.is_a?(Event), "Oh dear, the event wasn't an event!")
+      end
+
+     def test_person
+         t = EventDSL.new
+         t.person "test", Date.today-10, Date.today, "a good man" do ||
+             event "test event", Date.today-5, "test event"
+         end
+         p = t.people[0]
+         assert(p.is_a?(Person), "Oh god, the person wasn't a person!")
+         # Later, we could add more for long_event or war
+     end
+        def test_group
+            t = EventDSL.new
+            t.group :test do
+                event "Test", 6, "test"
+                person "Test", 6, 7, "test"
+            end 
+
+            x = t.events.flatten
+            
+            assert_equal(3, x.length)
+            x.each { |e| assert_equal(:test, e.group) }
+        end
+    end
+end

data/test/test_event.rb

@@ -0,0 +1,50 @@
+require "test/unit"
+require "chronograph/event"
+
+module Chronograph
+    class TestChronograph < Test::Unit::TestCase
+        def test_parse_date
+            assert_equal(Date.today, parse_date(Date.today))
+            assert_equal(Date.new(2010), parse_date(2010))
+        end
+
+        def test_errors
+            assert_raise(TypeError) { Event.new(nil, nil, nil, nil)  }
+        end
+
+        def test_recall
+            name = :test
+            date = Date.today
+            desc = "cool"
+            group = :green
+            e = Event.new(name, date, desc, group)
+            assert_equal(name, e.name)
+            assert_equal(date, e.date)
+            assert_equal(desc, e.desc)
+            assert_equal(group, e.group)
+        end
+
+        def test_to_table_html
+            name = :test
+            date = Date.today
+            desc = "cool"
+            group = :green
+            e = Event.new(name, date, desc, group)
+            # First we test without making use of Kramdown
+            assert_equal("<tr class=\"#{group}\">"+
+               "<td class=\"date\">#{date}</td>"+
+               "<td class=\"name\">#{name}</td>"+
+               "<td class=\"desc\"><p>#{desc}</p>\n</td>"+
+               "</tr>", e.to_table_html)
+            desc = "_cool_"
+            e = Event.new(name, date, desc, group)
+            # Now we start messing around with Kramdown. Note the redefinition of desc to surround cool with underscores
+            assert_equal("<tr class=\"#{group}\">"+
+               "<td class=\"date\">#{date}</td>"+
+               "<td class=\"name\">#{name}</td>"+
+               "<td class=\"desc\"><p><em>cool</em></p>\n</td>"+
+               "</tr>", e.to_table_html)
+        end
+        # And that's all she wrote, folks. There isn't much else to test.
+    end
+end

data/test/test_person.rb

@@ -0,0 +1,35 @@
+require "test/unit"
+require "chronograph/person"
+
+module Chronograph
+    class TestPerson < Test::Unit::TestCase
+        def setup
+            @t = nil
+            assert_nothing_raised(Exception) do
+                @t = Person.new("test", Date.today, Date.today+10, "this was awesome", Event.new("test event", Date.today+5, "test event"))
+            end
+        end
+       
+        def test_begining_event
+           b = @t.begining_event 
+           assert(b.is_a?(Event), "The begining event is not an event!")
+
+           e = @t.ending_event
+           assert(e.is_a?(Event), "The ending event is not an event!")
+        end
+
+        def test_recall
+            name = "test"
+            begining = Date.new(2000)
+            ending = Date.new(2010)
+            desc = "this is awesome"
+            event = Event.new("test", Date.new(2005), "awesome")
+
+            x = Person.new(name, begining, ending, desc, event)
+            assert_equal(name, x.name)
+            assert_equal(begining, x.birth)
+            assert_equal(ending, x.death)
+        end
+
+    end
+end

data/test/test_timeline.rb

@@ -0,0 +1,14 @@
+require "test/unit"
+require "chronograph/timeline"
+
+module Chronograph
+    class TestTimeline < Test::Unit::TestCase
+      def test_sanity
+          assert_nothing_raised(Exception) do
+              t = Timeline.new do
+                  event "Test", 2010, "awesome"
+              end
+          end
+      end
+    end
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification 
+name: chronograph
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+    - 0
+    - 0
+    - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+  - Indigo Casson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-02 00:00:00 -08:00
+default_executable: 
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: rubyforge
+    prerelease: false
+    requirement: &id001 !ruby/object:Gem::Requirement 
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            segments: 
+              - 2
+              - 0
+              - 4
+            version: 2.0.4
+    type: :development
+    version_requirements: *id001
+  - !ruby/object:Gem::Dependency 
+    name: hoe
+    prerelease: false
+    requirement: &id002 !ruby/object:Gem::Requirement 
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            segments: 
+              - 2
+              - 7
+              - 0
+            version: 2.7.0
+    type: :development
+    version_requirements: *id002
+description: Chronograph is a Ruby DSL for making timelines
+email: 
+  - atamiser@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+  - History.txt
+  - Manifest.txt
+  - README.txt
+files: 
+  - .autotest
+  - History.txt
+  - Manifest.txt
+  - README.txt
+  - Rakefile
+  - lib/chronograph.rb
+  - lib/chronograph/dsl.rb
+  - lib/chronograph/event.rb
+  - lib/chronograph/person.rb
+  - lib/chronograph/timeline.rb
+  - test/test_timeline.rb
+  - test/test_dsl.rb
+  - test/test_person.rb
+  - test/test_event.rb
+  - examples/programing_example.rb
+has_rdoc: true
+homepage: http://geeklob.wordpress.com
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+  - --main
+  - README.txt
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+          - 0
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+          - 0
+        version: "0"
+requirements: []
+
+rubyforge_project: chronograph
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Chronograph is a Ruby DSL for making timelines
+test_files: 
+  - test/test_timeline.rb
+  - test/test_person.rb
+  - test/test_event.rb
+  - test/test_dsl.rb