text_record 0.0.1

data/.gitignore

@@ -0,0 +1 @@
+coverage/

data/Rakefile

@@ -0,0 +1,40 @@
+require 'rubygems'
+require 'spec'
+require 'spec/rake/spectask'
+
+desc "Run all specs"
+Spec::Rake::SpecTask.new('spec') do |t|
+	t.spec_opts = ['--colour --format specdoc --loadby mtime --reverse']
+	t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+desc "Print specdocs"
+Spec::Rake::SpecTask.new(:doc) do |t|
+	t.spec_opts = ["--format", "specdoc", "--dry-run"]
+	t.spec_files = FileList['spec/*_spec.rb']
+end
+
+desc "Generate RCov code coverage report"
+Spec::Rake::SpecTask.new('rcov') do |t|
+	t.spec_files = FileList['spec/*_spec.rb']
+	t.rcov = true
+	t.rcov_opts = ['--exclude', '/gems/']
+end
+
+task :default => :spec
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "text_record"
+    gemspec.summary = "Models through text files"
+    gemspec.description = "Write your models in text files through YAML/Makdown/TextFile whatever you please. Take the forms out of your code and harness the power of your favorite editor."
+    gemspec.email = "Adman1965@gmaiil.com"
+    gemspec.homepage = "http://github.com/Adman65/text_record"
+    gemspec.authors = ["Adam Hawkins"]
+  end
+  
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/text_record/attribute.rb

@@ -0,0 +1,27 @@
+module TextRecord
+  class Attribute
+    attr_reader :name, :options    
+    
+    def self.for_options(options) 
+      (options[:from].eql?(:yml)) ? YAMLAttribute : FileAttribute      
+    end
+    
+    def initialize(name, options) 
+      @name = name
+      @options = options
+    end    
+  end
+  
+  class YAMLAttribute < Attribute
+    def parse(obj)
+      obj.instance_variable_set("@#{name.to_s.underscore}".to_sym, obj.yml[name.to_s.camelcase])
+    end
+  end
+  
+  class FileAttribute < Attribute
+    def parse(obj)
+      file_contents = IO.read("#{obj.directory}/#{options[:from]}")
+      obj.instance_variable_set("@#{name.to_s.underscore}".to_sym, file_contents)
+    end
+  end
+end

data/lib/text_record/base.rb

@@ -0,0 +1,65 @@
+require 'yaml'
+require 'forwardable'
+
+module TextRecord
+  class Base
+    extend Forwardable
+    
+    attr_reader :slug
+   
+    def_delegators :configuration, :content_path, :attribute_file
+
+    # Since attributes are unique to each subclass, have to the object's metaclass since it will be
+    # unique to each subclass
+    
+    class << self
+      attr_reader :attributes #aka @attributes in this block
+      
+      def attribute(name, options = {})
+        options.assert_valid_keys :from
+
+        @attributes ||= []  
+        options[:from] ||= :yml   
+
+        self.class_eval do
+          attr_reader name.to_s.underscore.to_sym
+        end
+
+        @attributes << Attribute.for_options(options).new(name, options)
+      end
+    end
+    
+    # class methods
+    def self.directory
+      File.join(TextRecord.configuration.content_path, self.name.pluralize.underscore)
+    end
+     
+    # Instance Methods
+    def initialize(path)
+      @slug = path
+      
+      raise SlugNotFoundError.new("#{directory} could not be found.") unless File.directory?(directory)
+
+      self.class.attributes.each do |attribute| # class attributes, attr_readers to be added to object
+        attribute.parse(self)
+      end     
+    end   
+    
+    def configuration
+      TextRecord.configuration
+    end
+    
+    def directory
+      name = self.class.name.underscore.pluralize
+      File.join(content_path, name, slug)
+    end
+
+    def yml_file
+      File.join(directory, attribute_file)
+    end
+
+    def yml
+      @yml ||= YAML.load_file(yml_file)
+    end
+  end
+end

data/lib/text_record/configuration.rb

@@ -0,0 +1,21 @@
+module TextRecord 
+  def self.configuration
+    @configuration ||= Configuration.new
+  end  
+  
+  
+  def self.configure(config=configuration)
+    yield config if block_given?
+    @configuration = config
+  end
+
+  
+  class Configuration
+    attr_accessor :content_path
+    attr_accessor :attribute_file
+    
+    def initialize
+      self.attribute_file = "attributes.yml"
+    end
+  end
+end

data/lib/text_record/errors.rb

@@ -0,0 +1,13 @@
+module TextRecord
+  # General error class
+  class TextRecordError < StandardError
+  end
+  
+  # Raised when the attribute file cannot be found
+  class AttributeFileNotFoundError < TextRecordError
+  end
+  
+  # Raised when slug cannot be found
+  class SlugNotFoundError < TextRecordError
+  end
+end

data/lib/text_record.rb

@@ -0,0 +1,14 @@
+require 'rubygems'
+begin
+  require 'active_support'
+rescue
+  require 'active_support'
+end
+
+module TextRecord
+end
+
+require 'text_record/configuration'
+require 'text_record/errors'
+require 'text_record/attribute'
+require 'text_record/base'

data/readme.markdown

@@ -0,0 +1,76 @@
+# TextRecord
+
+I needed to create a personal website with a lot of hand written content like blog posts, book reviews, and project documentations. Being a lazy programmer, I didn't want to have to write useless admin interfaces for creating all this stuff. Also, you can't get the full editing experience inside a textarea. TextMate totally owns textareas. So I needed an easy way to create massive amounts of text and organize them. Essentially, I wanted a way to treat my website as an open word document that I could save and push to heroku.
+
+After playing around with the idea and implementation I came up with TextRecord. TextRecord uses patterns from ActiveRecord to model objects in various text files.
+
+# Example
+
+## Install TextRecord
+
+    sudo gem install text_record # not gemmed yet
+    
+## Creating a Model
+
+All model files live in the content directory. Then each model instance has its own folder. The folder name is the model's slug. Inside each slug directory are the files that contain the model's attributes. Here is an exmaple folder structure
+
+    /content
+      /blog_posts
+        /TextRecordTest
+          attributes.yml
+          post.markdown
+          
+Folder names under content should be underscored. Your slug should be something simple either in camelcase or dashed. Think of the slug has an id column in table.
+
+Most of the time your attribute will come from the attributes.yml. Defining attributes in the yml file is easy. Here is an example attributes.yml:
+
+    Title: Introducting TextRecord
+    
+    Introduction: This is a paragraph explaining TextRecord
+    
+    Tags: [Ruby, Gems, TextRecord]
+    
+As you can see this is just vanilla YAML. You can use any YAML sturcture: list, hashes, blocks etc. They are translated into their Ruby equivalents using Ruby's YAML libary. Next we define what attributes to load from the file. By defining the attributes to load instead of autoloading everything in file, you can keep some things in 'development' mode. For example, you're working on creating summaries for long posts, but aren't ready to use them in production yet. Now, lets create the Blog Post model.
+
+    # blog_post.rb
+    BlogPost < TextRecord::Base
+      attribute :title
+      attribute :introduction
+      attribute :tags
+    end
+  
+Use the attribute class method to define methods. Attribute names should be underscored. Attribute names in the yaml file should be camel cased. BlogPost correspond to blog_posts under /content. Finally configure TextRecord.
+
+    TextRecord.configure do |config|
+      config.content_path = "/path/to/content"
+    end
+    
+Now you can instantiate your models:
+
+    blog_post = BlogPost.new 'TextRecordText' # argument is a slug
+    #<BlogPost:0x101e1ee00 @tags=["Ruby", "Gems", "TextRecord"], @slug="TextRecord", @introduction="This is a paragraph explaining TextRecord", @title="Introducting TextRecord", @yml={"Title"=>"Introducting TextRecord", "Tags"=>["Ruby", "Gems", "TextRecord"], "Introduction"=>"This is a paragraph explaining TextRecord"}>
+    >> blog_post.title
+    => "Introducting TextRecord"
+    >> blog_post.slug
+    => "TextRecord"
+    >> blog_post.tags
+    => ["Ruby", "Gems", "TextRecord"]
+    
+# Using Other Files
+
+You can also pull in attributes from other files. For example, storing markdown/textile or formats that require spacing/tabs in yaml files is difficult. The attribute takes on option: :from. Use from to tell TextRecord to load an attribute from another file. For exmaple, the post text is stored in markdown as 'post' from post.markdown. post.markdown is located under a slug directory.
+
+    class BlogPost < TextRecord::Base
+      attribute :post, :from => 'post.markdown'
+    end
+
+That will load the contents for post.markdown into the post attr_reader
+    
+    
+# Limitations
+
+TextRecord models are **READ ONLY**. All attributes are attr_readers. Why? Because TextRecord is only a way to encapsulate your text files into objects that you can use in your program. If you want to created/edit/delete models, update your slugs/text files.
+
+# Working On
+* **ActiveRecord style finders**    
+  

data/spec/app/content/blog_posts/TextRecord/attributes.yml

@@ -0,0 +1,5 @@
+Title: Text Record
+
+IntroductionText: This is an introduction paragraph
+
+Fixnum: 5

data/spec/app/content/blog_posts/TextRecord/post.markdown

@@ -0,0 +1 @@
+This is from the markdown file

data/spec/app/models/blog_post.rb

@@ -0,0 +1,5 @@
+class BlogPost < TextRecord::Base
+  attribute :title
+  attribute :introduction_text
+  attribute :text, :from => 'post.markdown'
+end

data/spec/base_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe TextRecord::Base do 
+  describe "#attribute" do    
+    
+    it "should raise an error if the keys are invalid" do
+      lambda {TextRecord::Base.attribute(:name, :adfsadf => "asdfasdfasdf")}.should raise_error
+    end
+    
+    describe TextRecord::YAMLAttribute do
+      before(:each) do
+        class AttributeTest < TextRecord::Base
+          attribute :name
+        end
+      end
+      
+      after(:each) do
+        AttributeTest.reset_attributes!
+      end        
+      
+      it "should create a new YAML attribute by default" do      
+        AttributeTest.attributes.first.should be_a(TextRecord::YAMLAttribute)
+      end
+    
+      it "should set the @name of a new YAML attribute" do      
+        AttributeTest.attributes.first.name.should eql(:name)
+      end
+    end
+    
+    describe TextRecord::FileAttribute do
+      before(:each) do
+        class AttributeTest < TextRecord::Base
+          attribute :post, :from => 'post.md'
+        end
+      end
+      
+      after(:each) do
+        AttributeTest.reset_attributes!
+      end
+    
+      it "should should create a new FILEAttribute when given a :from key" do
+        AttributeTest.attributes.first.should be_a(TextRecord::FileAttribute)
+      end
+    
+      it "should set the @name of a new File attribute" do
+        AttributeTest.attributes.first.name.should eql(:post)
+      end
+      
+      it "should set the @options for a new File attribute" do
+        AttributeTest.attributes.first.options.should eql({:from => 'post.md'})
+      end
+    end
+  end  
+end

data/spec/blog_post_spec.rb

@@ -0,0 +1,84 @@
+# this spec essentially tests TextRecord::Base since TextRecord::Base is essentially
+# an abstract class.
+
+require 'spec_helper'
+
+describe BlogPost do
+  describe "#directory" do
+    it "should return the TextRecord.configuration's content_path joined with the class name" do
+      BlogPost.directory.should eql(File.join(TextRecord.configuration.content_path, "blog_posts"))
+    end
+  end
+  
+  describe "#initialize" do
+    it "should raise an error given an incorrect slug" do
+      # tests for TextRecord::SlugNotFound that has the slug in the error description somewhere
+      lambda { BlogPost.new("fakeslug") }.should raise_error(TextRecord::SlugNotFoundError, /fakeslug/)
+    end
+    
+    it "should set the slug" do
+      BlogPost.new("TextRecord").slug.should eql("TextRecord")
+    end
+  end
+end
+
+describe "A Blog Post" do
+  before(:each) do
+    @blog_post = BlogPost.new('TextRecord')
+  end
+  
+  describe "attributes from yaml" do
+    it "should have a title attribute" do
+      @blog_post.respond_to?(:title).should be_true
+    end
+
+    it "should make the title a string" do
+      @blog_post.title.should be_a(String)
+    end
+    
+    it "should take the title from the file" do
+      @blog_post.title.should eql('Text Record')
+    end
+    
+    it "should not have title writer" do
+      @blog_post.respond_to?(:title=).should be_false
+    end
+    
+    it "should have a slug" do
+      @blog_post.slug.should eql('TextRecord')
+    end
+    
+    it "should have an introduction_text attribute" do
+      @blog_post.respond_to?(:introduction_text).should be_true
+    end
+    
+    it "should set the introduction_text from the yaml file" do
+      @blog_post.introduction_text.should eql('This is an introduction paragraph')
+    end
+    
+    it "should not have an attribute writer for introduction_text" do
+      @blog_post.respond_to?(:introduction_text=).should be_false
+    end
+  end
+  
+  describe "attributes from files" do
+    it "should have a text attribute" do
+      @blog_post.respond_to?(:text).should be_true
+    end
+    
+    it "should assign text to the whole file contents" do
+      @blog_post.text.should eql('This is from the markdown file')
+    end
+    
+    it "should not have an text attribute writer" do
+      @blog_post.respond_to?(:text=).should be_false
+    end
+  end
+  
+  
+  describe "#directory" do
+    it "should return the content path plus the slug" do
+      BlogPost.new('TextRecord').directory.should eql(File.join(TextRecord.configuration.content_path, "blog_posts","TextRecord"))
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,34 @@
+require 'rubygems'
+require 'spec'
+
+LIB_PATH = File.expand_path("#{File.dirname(__FILE__)}/../lib")
+$: << LIB_PATH
+
+require 'text_record'
+
+APP_PATH = File.expand_path("#{File.dirname(__FILE__)}/app")
+
+TextRecord.configure do |config|
+  config.content_path = "#{APP_PATH}/content"
+end
+
+$: << "#{APP_PATH}/models"
+
+Dir["#{APP_PATH}/models/*.rb"].each do |model|
+  require model
+end
+
+Spec::Runner.configure do |config|
+  config.after(:each) do
+    # nothing as of now
+  end
+end
+
+# Little monkey patch to reset attributes during testing
+module TextRecord
+  class Base
+    def self.reset_attributes!
+      @attributes = []
+    end
+  end
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: text_record
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Adam Hawkins
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-04 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: Write your models in text files through YAML/Makdown/TextFile whatever you please. Take the forms out of your code and harness the power of your favorite editor.
+email: Adman1965@gmaiil.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Rakefile
+- VERSION
+- lib/text_record.rb
+- lib/text_record/attribute.rb
+- lib/text_record/base.rb
+- lib/text_record/configuration.rb
+- lib/text_record/errors.rb
+- readme.markdown
+- spec/app/content/blog_posts/TextRecord/attributes.yml
+- spec/app/content/blog_posts/TextRecord/post.markdown
+- spec/app/models/blog_post.rb
+- spec/base_spec.rb
+- spec/blog_post_spec.rb
+- spec/configuration_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/Adman65/text_record
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Models through text files
+test_files: 
+- spec/app/models/blog_post.rb
+- spec/base_spec.rb
+- spec/blog_post_spec.rb
+- spec/configuration_spec.rb
+- spec/spec_helper.rb