maneki 1.0.0

data/README.markdown

@@ -0,0 +1,105 @@
+Maneki
+======
+
+Maneki is a simple file-based model for your Ruby projects. Give it a directory and it will parse any relevant files within.
+
+For example you might have a model like this:
+
+    class Document < Maneki
+      path_is '../content/documents'
+    end
+
+...and a directory, `documents`, that contains a bunch of markdown documents:
+
+    documents/
+      first-document.text
+      second-document.text
+      third-document.text
+
+...and each file might be in a form similar to:
+
+    # This is the title
+    
+     - published: yes
+     - authors: Aristoclea Cattington, Sebastian Fluffybottom
+    
+    This is the content of the document. It is written in Markdown.
+
+This example parsed document would have the following properties:
+
+ - Title: This is the title
+ - Headers:
+   - Published: True
+   - Authors: 
+     - 'Aristoclea Cattington'
+     - 'Sebastian Fluffybottom'
+ - Body: This is the content of the document. It is written in Markdown.
+
+
+Getting some documents
+----------------------
+
+If you want all of the documents.
+
+    Document.all
+
+Or you can find items by their slug.
+
+    Document.find :slug => 'test-document'
+    
+Or you can also search for the inclusion of certain headers.
+
+    Document.find :headers => { :published => true }
+    Document.find :headers => { :authors => 'Aristoclea Cattington' }
+
+You can also grab any documents from a given category (read on).
+
+
+Document categories
+-------------------
+
+If documents are found within folders then they will also be added to a categorised list.
+
+For example, given this directory structure:
+
+    content/
+      documents/
+        first-document.text
+        second-document.text
+        third-document.text
+      projects/
+        a-project.text
+        here-is-another-project.text
+
+Now assume that Maneki has its path set to `content`:
+
+    Maneki.path = 'content'
+
+Here if we want to grab any posts we can just ask for the category.
+
+    Maneki.documents
+
+Here we will get:
+
+ - First document
+ - Second document
+ - Third document
+
+Whereas if you did:
+
+    Maneki.projects
+
+You would get:
+
+ - A Project
+ - Here is another project
+
+If you want to get a list of the found categories then ask for it.
+
+    Maneki.categories
+
+
+Suggestions?
+------------
+
+[Find me on Twitter](http://twitter.com/nathanhoad)

data/Rakefile

@@ -0,0 +1,41 @@
+task :default => :test
+
+
+### TESTING ###
+desc 'Run unit tests'
+task 'test' do |t|
+  sh 'ruby test/test_all.rb'
+end
+
+
+### PACKAGING ###
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "maneki"
+    gemspec.summary = "A simple file-based model for your Ruby projects"
+    gemspec.description = "Maneki loads and parses any relevant text files in a given directory"
+    gemspec.email = "nathan@nathanhoad.net"
+    gemspec.homepage = "http://github.com/nathanhoad/maneki"
+    gemspec.authors = ["Nathan Hoad"]
+    gemspec.files = `git ls-files`.split("\n").sort.reject{ |file| file =~ /^\./ }
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install jeweler"
+end
+
+
+### DOCUMENTATION ###
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist? 'VERSION'
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "Maneki #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/lib/maneki.rb

@@ -0,0 +1,241 @@
+# = Maneki
+# 
+# Load documents from a directory and parse them. The idea is that
+# any of the given documents (Markdown only for now) should be readable
+# in their own format without parsing but be formatted in such way as 
+# to present meta information (title, headers, etc) in an easily parsable
+# way.
+class Maneki  
+  # Set the search path
+  def self.path= (value)
+    path value
+  end
+  
+  # Set or return the search path
+  def self.path (value = nil)
+    @path = value if value
+    @category = File.basename(value) unless @category
+    @path
+  end
+  
+
+  # Set the general category for these documents
+  def self.category (value = nil)
+    @category = value
+    @category
+  end
+  
+  
+  # Get a list of all categories
+  def self.categories
+    prepare
+    @categorised.keys
+  end
+  
+  
+  # Grab all documents
+  def self.all
+    prepare
+  end
+  
+  
+  # Search for any documents
+  def self.find (args = {})
+    if args[:slug] or args.is_a? String
+      return find_by_slug(args[:slug] || args)
+    end
+    
+    match = args[:match] || :any
+    args.delete(:match)
+    
+    all.select do |item|
+      matches = 0
+            
+      if args[:title] 
+        if item.title == args[:title]
+          matched ||= true if match == :any
+          matches += 1 if match == :all
+        else
+          matched ||= false if match == :all
+        end
+      end
+      
+      if args[:body]
+        if item.body.downcase.include? args[:body].downcase
+          matched ||= true if match == :any
+          matches += 1 if match == :all
+        else
+          matched ||= false if match == :all
+        end
+      end
+      
+      if args[:headers]
+        args[:headers].each_pair do |header, value|
+          if item.headers[header] and (item.headers[header] == value or item.headers[header].include? value)
+            matched ||= true if match == :any
+            matches += 1 if match == :all
+          else
+            matched ||= false if match == :all
+          end
+        end
+      end
+      
+      matched || (matches >= args.size)
+    end
+  end
+  
+  
+  # The previous document before a given document
+  def self.previous_before (document, args = {})
+    prepare
+    if args[:category]
+      index = @categorised[args[:category]].index(document)
+    else
+      index = @documents.index(document)
+    end
+    @documents[index - 1] unless index == 0
+  end
+  
+  # The next document after a given document
+  def self.next_after (document, args = {})
+    prepare
+    if args[:category]
+      index = @categorised[args[:category]].index(document)
+    else
+      index = @documents.index(document)
+    end
+    @documents[index + 1] unless index == @documents.length
+  end
+  
+  
+  # Look up a document category
+  def self.method_missing (method, *args)
+    prepare
+    @categorised[method.to_s] unless @categorised.nil?
+  end
+  
+  
+  attr_accessor :filename, :category, :slug, :headers, :title, :body
+  
+  # Create a new document
+  def initialize (args = {})
+    @filename = File.expand_path(args[:filename])
+	  
+		@body = ''
+		if File.exists? @filename		  
+			@category = File.dirname(@filename).split('/').last unless @category		
+			@slug = @filename.gsub(File.expand_path(self.class.path) + '/', '').gsub(/\..+$/, '')
+			
+			body = File.open(@filename).readlines
+			body.each do |line|
+				line.gsub!("\r", '') # fix up any DOS EOLs
+			end
+
+			title = body.find { |item| /^\#.+/.match item }
+			body = body[2..body.length-1] if title # consume title
+
+      # check for headers
+      @headers = Hash.new
+      if /^\s?\-.+/.match(body[0])
+			  headers_end = body.index("\n") || 1
+				headers = body[0..headers_end-1] if headers_end # next blank line is end of headers
+
+				body_start = 1
+				body_start = body.index(headers.last) + 1 if headers
+				body = body[body_start..body.length - 1] if title
+
+				headers.each do |header|
+					unless header.strip == '' or /^\#.+/.match header
+						values = header.gsub(/^\s?\-/, '').strip.split(/:\s/)
+						key = values.shift.downcase.gsub(/[^\w\_]+/, '_').to_sym
+						value = values.join(': ').strip
+						# check for special header values (true, false, lists, etc)
+						if ['true', 't', 'yes', 'y'].include? value
+						  value = true
+						elsif ['false', 'f', 'no', 'n'].include? value
+						  value = false
+						elsif value.include? ','
+						  value = value.split(/\,\s?/)
+						end
+						@headers[key] = value
+					end
+				end if headers
+			end
+
+			# title
+			@title = title.gsub(/^\#\s/, '').strip if title
+
+			# content
+			@body = body.join("").strip
+		end
+  end
+  
+  
+  # A callback to see if this document should be added to the list
+  def valid?
+    true
+  end
+  
+  
+  # Documents are the same if their IDs are the same
+  def == (rhs)
+    @slug == rhs.slug
+  end
+  
+  
+  # Sort by filename
+  def <=> (rhs)
+    @filename <=> rhs.filename
+  end
+  
+  
+  # Stringify this document
+  def to_s
+    title
+  end
+  
+  
+  protected    
+    
+    # Grab the @path with a slash if needed
+    def self.path_with_slash
+      files_path = File.expand_path(@path)
+      files_path += '/' unless files_path.end_with? '/'
+      files_path
+    end
+    
+    
+    # Find a document by its slug
+    def self.find_by_slug (slug)
+      filename = path_with_slash + slug + '.text'
+      if File.exists? filename
+        document = new(:filename => filename)
+        document if document.valid?
+      end
+    end
+    
+    
+    # Load the any documents in the files path
+    def self.prepare (args = {})
+      if @documents.nil? or args[:force]
+        files_path = path_with_slash
+        
+        @documents = []
+        @categorised = {}
+
+  			# find some documents
+  			Dir.glob(["#{files_path}*", "#{files_path}*/*"]).each do |filename|
+  			  if filename.split('.').last == 'text'
+            document = new(:filename => filename)
+            if document.valid?
+              @documents << document
+              @categorised[document.category] ||= []
+              @categorised[document.category] << document
+            end
+          end
+  		  end
+  		  @documents.sort!
+  		end
+  		@documents
+    end
+end

data/maneki.gemspec

@@ -0,0 +1,58 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{maneki}
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Nathan Hoad"]
+  s.date = %q{2010-05-22}
+  s.description = %q{Maneki loads and parses any relevant text files in a given directory}
+  s.email = %q{nathan@nathanhoad.net}
+  s.extra_rdoc_files = [
+    "README.markdown"
+  ]
+  s.files = [
+    "README.markdown",
+     "Rakefile",
+     "VERSION",
+     "lib/maneki.rb",
+     "maneki.gemspec",
+     "test/chapter.rb",
+     "test/content/chapters/01-the-first-chapter.text",
+     "test/content/chapters/02-chapter-2.text",
+     "test/content/chapters/03-chapter-with-headers.text",
+     "test/content/chapters/04-different-chapter.text",
+     "test/content/documents/first-document.text",
+     "test/content/documents/second-document.text",
+     "test/content/documents/third-document.text",
+     "test/test_all.rb",
+     "test/test_chapters.rb",
+     "test/test_maneki.rb"
+  ]
+  s.homepage = %q{http://github.com/nathanhoad/maneki}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{A simple file-based model for your Ruby projects}
+  s.test_files = [
+    "test/chapter.rb",
+     "test/test_all.rb",
+     "test/test_chapters.rb",
+     "test/test_maneki.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/test/chapter.rb

@@ -0,0 +1,3 @@
+class Chapter < Maneki
+  path File.dirname(__FILE__) + '/content/chapters'
+end

data/test/content/chapters/01-the-first-chapter.text

@@ -0,0 +1,3 @@
+# Chapter 1: The first chapter
+
+This is the content of this chapter.

data/test/content/chapters/02-chapter-2.text

@@ -0,0 +1,3 @@
+# Chapter 2: Crazy cats
+
+This is the second chapter.

data/test/content/chapters/03-chapter-with-headers.text

@@ -0,0 +1,8 @@
+# Chapter 3: Chapter with Headers
+
+ - Author: Nathan Hoad
+ - List values: These, are, list, items
+ - Boolean value: yes
+ - Another boolean: no
+
+Here is a chapter written by a guest author. It has some headers.

data/test/content/chapters/04-different-chapter.text

@@ -0,0 +1,6 @@
+# Alpha sorted first title
+
+ - Boolean value: yes
+ - Facts: This chapter should be sorted first if by title
+
+Here is some text.

data/test/content/documents/first-document.text

@@ -0,0 +1,6 @@
+# This is the first document
+
+ - published: yes
+ - author: Nathan Hoad
+
+Here is some content for this document.

data/test/content/documents/second-document.text

@@ -0,0 +1,3 @@
+# Here is the second document
+
+The content for this document is this.

data/test/content/documents/third-document.text

@@ -0,0 +1,3 @@
+# Third document
+
+Yep. This is the third one.

data/test/test_all.rb

@@ -0,0 +1,5 @@
+require 'test/unit'
+
+Dir.glob('test/test_*.rb').each do |filename|
+	require filename if filename != __FILE__
+end

data/test/test_chapters.rb

@@ -0,0 +1,50 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/maneki'
+require File.dirname(__FILE__) + '/chapter'
+
+
+class TestChapters < Test::Unit::TestCase
+	def test_document_load	  
+		chapter = Chapter.new :filename => File.dirname(__FILE__) + '/content/chapters/01-the-first-chapter.text'		
+		assert_kind_of Chapter, chapter
+		assert_equal '01-the-first-chapter', chapter.slug
+		assert_equal 'Chapter 1: The first chapter', chapter.title
+		assert_equal 'This is the content of this chapter.', chapter.body
+		assert_equal({}, chapter.headers)
+	end
+
+	def test_chapters_load
+		assert_not_equal 0, Chapter.all.size
+	end
+	
+	def test_find
+	  chapter = Chapter.find '01-the-first-chapter'
+	  assert_kind_of Chapter, chapter
+	  assert_equal 'Chapter 1: The first chapter', chapter.title
+	  
+	  chapters = Chapter.find :headers => { :boolean_value => true }, :body => 'some headers', :match => :all
+	  assert_equal 1, chapters.size
+	  
+	  chapters = Chapter.find :headers => { :boolean_value => true }, :body => 'some headers', :match => :any
+	  assert_equal 2, chapters.size
+	  
+	  chapters = Chapter.find :headers => { :boolean_value => true }
+	  assert_not_equal 0, chapters.size
+	  
+	  chapters = Chapter.find :headers => { :list_values => 'are' }
+	  assert_not_equal 0, chapters.size
+  end
+  
+  def test_headers
+    chapter = Chapter.find '01-the-first-chapter'
+    assert_equal({}, chapter.headers)
+    
+    chapter = Chapter.find '03-chapter-with-headers'
+    assert_not_equal({}, chapter.headers)
+    assert_equal 'Here is a chapter written by a guest author. It has some headers.', chapter.body
+    
+    assert_kind_of Array, chapter.headers[:list_values]
+    assert_kind_of TrueClass, chapter.headers[:boolean_value]
+    assert_kind_of FalseClass, chapter.headers[:another_boolean]
+  end
+end

data/test/test_maneki.rb

@@ -0,0 +1,36 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/maneki'
+
+
+class TestManeki < Test::Unit::TestCase
+	def setup
+		@content_path = File.dirname(__FILE__) + '/content'		
+		Maneki.path = @content_path
+	end
+	
+  def test_documents_categories    
+    assert Maneki.categories.include?('documents')
+    assert_not_equal 0, Maneki.documents.size
+    
+    documents = Maneki.documents
+    assert_kind_of Array, documents
+  end
+  
+  def test_previous_and_next
+    documents = Maneki.documents
+    first = documents[0]
+    second = documents[1]
+    other_second = Maneki.find 'documents/second-document'
+    third = documents[2]
+    
+    assert_not_nil Maneki.previous_before(first)
+    assert_nil Maneki.previous_before(first, :category => 'documents')
+    assert_equal second, Maneki.next_after(first)
+    assert_equal other_second, Maneki.next_after(first)
+    assert_equal third, Maneki.next_after(second)
+    assert_equal third, Maneki.next_after(other_second)
+    assert_nil Maneki.next_after(third)
+    
+    assert_equal first, Maneki.next_after(Maneki.previous_before(first))
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: maneki
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Nathan Hoad
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-22 00:00:00 +10:00
+default_executable: 
+dependencies: []
+
+description: Maneki loads and parses any relevant text files in a given directory
+email: nathan@nathanhoad.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- README.markdown
+- Rakefile
+- VERSION
+- lib/maneki.rb
+- maneki.gemspec
+- test/chapter.rb
+- test/content/chapters/01-the-first-chapter.text
+- test/content/chapters/02-chapter-2.text
+- test/content/chapters/03-chapter-with-headers.text
+- test/content/chapters/04-different-chapter.text
+- test/content/documents/first-document.text
+- test/content/documents/second-document.text
+- test/content/documents/third-document.text
+- test/test_all.rb
+- test/test_chapters.rb
+- test/test_maneki.rb
+has_rdoc: true
+homepage: http://github.com/nathanhoad/maneki
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A simple file-based model for your Ruby projects
+test_files: 
+- test/chapter.rb
+- test/test_all.rb
+- test/test_chapters.rb
+- test/test_maneki.rb