myobie-turbine-core 0.1.0

data/README

@@ -0,0 +1,6 @@
+This is the core engine of my turbine project: taking text and making sense of it.
+
+Look at the specs or at turbine-blog to help understand what this thing does.
+
+To run the specs:
+> bacon spec/**/*.rb spec/*.rb

data/Rakefile

@@ -0,0 +1,13 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "turbine-core"
+    gemspec.summary = "TODO"
+    gemspec.email = "nathan@myobie.com"
+    gemspec.homepage = "http://github.com/myobie/turbine-core"
+    gemspec.description = "TODO"
+    gemspec.authors = ["Nathan Herald"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install jeweler"
+end

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 1
+:patch: 0

data/lib/ext.rb

@@ -0,0 +1,63 @@
+class String
+  def slugify
+    self.dup.slugify!
+  end
+  
+  def slugify!
+    self.gsub!(/[^\x00-\x7F]+/, '') # Remove non-ASCII (e.g. diacritics).
+    self.gsub!(/[^a-z0-9\-_\+]+/i, '-') # Turn non-slug chars into the separator.
+    self.gsub!(/-{2,}/, '-') # No more than one of the separator in a row.
+    self.gsub!(/^-|-$/, '') # Remove leading/trailing separator.
+    self.downcase!
+    self
+  end
+  
+  def make_attr
+    self.downcase.to_sym
+  end
+end
+
+class Symbol
+  def html
+    (self.to_s + '_html').to_sym
+  end
+  
+  def make_attr
+    self.to_s.downcase.to_sym
+  end
+end
+
+class Array
+  def make_attrs
+    self.collect! { |a| a.to_s.downcase.to_sym }
+  end
+end
+
+### class instance vars that inherit down to children
+module ClassLevelInheritableAttributes
+  
+  PRIMITIVES = [NilClass, TrueClass, FalseClass, Fixnum, Float]
+  
+  def cattr_inheritable(*args)
+    @cattr_inheritable_attrs ||= [:cattr_inheritable_attrs]
+    @cattr_inheritable_attrs += args
+    args.each do |arg|
+      class_eval %(
+        class << self; attr_accessor :#{arg}; end
+      )
+    end
+    @cattr_inheritable_attrs
+  end
+
+  def inherited(subclass)
+    @all_children ||= []
+    @cattr_inheritable_attrs.each do |inheritable_attribute|
+      instance_var = "@#{inheritable_attribute}" 
+      current_value = instance_variable_get(instance_var)
+      current_value = current_value.dup unless PRIMITIVES.include?(current_value.class)
+      subclass.instance_variable_set(instance_var, current_value)
+    end
+    @all_children << subclass
+  end
+
+end

data/lib/importers/json_importer.rb

@@ -0,0 +1,14 @@
+class JsonImporter
+  
+  attr_accessor :result, :type
+  
+  def initialize(type)
+    @type = type
+    @result = {}
+  end
+  
+  def import(json_text)
+    @result = JSON.parse(json_text)
+  end
+  
+end

data/lib/importers/text_importer.rb

@@ -0,0 +1,113 @@
+class TextImporter
+  
+  attr_accessor :remainder, :result, :type
+  
+  def initialize(type)
+    @type = type
+    @result = []
+    @remainder = ''
+    @primary = nil
+    @heading = nil
+  end
+  
+  def import(text)
+    pull_pairs(text)
+    eval_primary_field
+    
+    @result
+  end
+
+  def pull_pairs(text)
+    last_pair_found = false
+  
+    text.each_line do |line|
+    
+      unless last_pair_found
+        possible_pair = detect_pair(line)
+        if possible_pair and possible_pair.captures.length == 2
+          key = possible_pair.captures[0].downcase.to_sym
+          value = possible_pair.captures[1]
+          number_of_lines = value.count("\n") + 1
+          @result << { key => value.strip }
+          next # don't put this in the remainder
+        else
+          last_pair_found = true
+        end#of if
+      end
+    
+      @remainder << line # keep this around, it might be useful
+    end#of each_line
+    
+    @remainder.strip!
+  end#of parse_pairs
+
+  def detect_pair(line)
+    line.strip.match(/(^[A-Za-z0-9_]+):(.+)/)
+  end
+  
+  def eval_primary_field
+    unless @remainder.blank? || @type.primary_field.blank?
+      @primary = @remainder
+      
+      eval_heading_field unless @type.heading_field.blank?
+      
+      save_primary
+      save_heading
+    end
+  end
+
+  def eval_heading_field
+    # check for an <h1> at the beginning of the primary and if it's there pull it out for the heading
+    possible_hone = remainder.match(/(.+)\n=+\n*|^# (.+)\w*\n*/)
+    
+    caps = []
+    caps = possible_hone.captures.compact unless possible_hone.blank?
+    
+    # if it's there, then parse it out of the remainder
+    if !possible_hone.blank? and caps.length == 1
+      @heading = caps.first
+      
+      ### Remove heading from text
+      @primary = @primary.
+        strip.
+        gsub(/^#{possible_hone.captures.first}\n=+\n*/, '').
+        gsub(/^# #{possible_hone.captures.first}\w*\n*/, '').
+        strip
+    end#of if
+  end#of eval_heading_field
+  
+  def save_primary
+    unless @primary.blank?
+      # see if a pair already exists for the primary_field
+      existing_primary = @result.select { |pair| pair.keys.first == @type.primary_field }
+      existing_primary = existing_primary.first
+    
+      # get rid of the primary_field if it's already there
+      @result.delete(existing_primary)
+    
+      # if there was any existing, prepend it to remanding
+      @primary = existing_primary.to_s + @primary unless existing_primary.blank?
+    
+      # append a new pair for the fields
+      @result << { @type.primary_field => @primary } unless @primary.blank?
+    end
+  end
+  
+  def save_heading
+    unless @heading.blank?
+      # see if a pair already exists for the primary_field
+      existing_heading = @result.select { |pair| pair.keys.first == @type.heading_field }
+      existing_heading = existing_heading.first
+    
+      # get rid of the primary_field if it's already there
+      @result.delete(existing_heading)
+    
+      # if there was any existing, prepend it to remanding
+      @heading = existing_heading.to_s + @heading unless existing_heading.blank?
+    
+      # append a new pair for the fields
+      @result << { @type.heading_field => @heading } unless @heading.blank?
+    end
+  end
+  
+end

data/lib/post_type.rb

@@ -0,0 +1,362 @@
+require 'rdiscount' # markdown
+require 'nokogiri'
+require 'uuidtools'
+
+class PostType
+  extend ClassLevelInheritableAttributes
+  include Extlib::Hook
+  
+  DEFAULT_FIELDS = [:published_at, :status, :slug, :trackbacks, :type, :tags]
+  
+  # vars to inherit down
+  cattr_inheritable :fields_list, :allowed_fields_list, :required_fields_list, :primary_field, :heading_field, 
+                    :specials_blocks, :defaults_blocks, :only_declared_fields, :always_use_uuid,
+                    :truncate_slugs, :markdown_fields
+  
+  # defaults for class instance inheritable vars
+  @fields_list = []
+  @allowed_fields_list = []
+  @required_fields_list = []
+  @primary_field = nil
+  @heading_field = nil
+  @specials_blocks = {}
+  @defaults_blocks = {}
+  @only_declared_fields = true
+  @always_use_uuid = false
+  @truncate_slugs = true
+  @markdown_fields = []
+  
+  
+  ### cattr_accessor
+  @@preferred_order = []
+  
+  def self.preferred_order
+    @@preferred_order
+  end
+  def self.preferred_order=(new_order)
+    @@preferred_order = new_order
+  end
+  ### cattr_accessor
+  
+  attr_accessor :content # where everything is stored
+  
+  ### basic setup methods for types of posts
+  def self.fields(*list) # NOTE: this is a replacing function, not addititve like the others
+    self.fields_list = list.make_attrs
+    self.allowed_fields_list = [DEFAULT_FIELDS, list.make_attrs].flatten.uniq
+  end
+  
+  def self.allow(*list)
+    self.allowed_fields_list = [self.allowed_fields_list, list.make_attrs].flatten.uniq
+  end
+  
+  def self.required(*list)
+    self.required_fields_list = [
+                                  self.required_fields_list,
+                                  list.make_attrs.reject { |l| !fields_list.include? l }
+                                ].flatten.uniq
+  end
+  
+  def self.primary(field)
+    field = field.make_attr
+    
+    if fields_list.include? field
+      self.primary_field = field
+      markdown field # primary is a markdown field by default
+    end
+  end
+  
+  def self.heading(field)
+    field = field.make_attr
+    self.heading_field = field if fields_list.include? field
+  end
+  
+  def self.special(field, &block)
+    field = field.make_attr
+    self.specials_blocks[field.make_attr] = block if fields_list.include? field
+  end
+  
+  def self.default(field, &block)
+    field = field.make_attr
+    self.defaults_blocks[field.make_attr] = block if fields_list.include? field
+  end
+  
+  def self.dynamic(field, &block)
+    field = field.make_attr
+    self.dynamic_blocks[field] = block
+    allow(field)
+  end
+  
+  def self.markdown(*list)
+    self.markdown_fields =  [
+                              self.markdown_fields,
+                              list.make_attrs.reject { |l| !fields_list.include? l }
+                            ].flatten.uniq
+                            
+    self.allowed_fields_list = [
+                                  self.allowed_fields_list, 
+                                  self.markdown_fields.collect { |m| m.html }
+                                ].flatten.uniq
+  end
+  
+  def set_attr(key, value)
+    key = key.make_attr
+    
+    unless value.blank?
+      @content[key] = value
+      
+      if self.class.markdown_fields.include?(key)
+        markdown = Markdown.new @content[key].strip
+        @content[key.html] = markdown.to_html.strip
+      else
+        @content.delete(key.html)
+      end
+    else
+      @content.delete(key)
+      @content.delete(key.html)
+    end
+  end
+  
+  def set_default(key, value)
+    set_attr(key, value) if blank_attr?(key)
+  end
+  
+  def blank_attr?(key)
+    get_attr(key).blank?
+  end
+  
+  alias :get_attr? :blank_attr?
+  
+  def get_attr(key, html = true)
+    key = key.make_attr
+    
+    if html && self.class.markdown_fields.include?(key)
+      @content[key.html]
+    else
+      @content[key]
+    end
+  end
+  
+  def delete_attr(key)
+    set_attr(key.make_attr, nil)
+  end
+  
+  alias :remove_attr :delete_attr
+  alias :del_attr :delete_attr
+  
+  # can be overriden to provide auto detection of type from a block of text
+  #
+  # Examples:
+  #   def self.detect?(text)
+  #     has_keys? text, :title, :body
+  #   end
+  #
+  #   def self.detect?(text)
+  #     has_required? text
+  #   end
+  #
+  #   def self.detect?(text)
+  #     has_one_or_more? text, :me
+  #   end
+  #
+  def self.detect?(text)
+    false
+  end
+  
+  # useful for detection
+  def self.has_keys?(text, *fields)
+    needed = fields.make_attrs
+    get_pairs_count(text, needed).length == needed.length
+  end
+  
+  def self.has_more_than_one?(text, field)
+    has_more_than? text, field, 1
+  end
+  
+  def self.has_one_or_more?(text, field)
+    has_more_than? text, field, 0
+  end
+  
+  def self.has_more_than?(text, field, amount)
+    get_pairs_count(text, [field]).length > amount
+  end
+  
+  def self.get_pairs(text)
+    TextImporter.new(self).import(text)
+  end
+  
+  def self.get_pairs_count(text, fields)
+    pairs = get_pairs(text)
+    pairs.reject { |pair| !fields.include?(pair.keys.first) }
+  end
+  
+  def self.has_required?(text)
+    has_keys? text, *self.required_fields_list
+  end
+  
+  # runs through the list of children looking for one that will work
+  def self.auto_detect(text)
+    list = self.preferred_order.blank? ? @all_children : self.preferred_order
+    
+    list.each { |l| return l.new(text) if l.detect?(text) }
+  end
+  
+  def content=(stuff) # !> method redefined; discarding old content=
+    @content = { :type => self.class.name.to_s }
+    import(stuff)
+    eval_specials
+    eval_defaults
+    parse_tags unless blank_attr?(:tags)
+    generate_slug if get_attr?(:slug)
+    @content
+  end#of content=
+  
+  def valid? # TODO: this doesn't work if there are no required fields and the slug is not unique
+    v = true
+    
+    if self.class.required_fields_list.blank?
+      v = false unless self.class.required_fields_list.reject { |item| !get_attr(item).blank? }.blank?
+    end
+    
+    v = false unless slug_is_unique
+    
+    v
+  end
+  
+  def initialize(text = nil)
+    if text
+      self.content = text
+      # sanitize_content_fields
+    end
+  end
+  
+  def save
+    if valid?
+      truncate_slug if self.class.truncate_slugs
+      fill_default_fields
+      send_to_storage
+    else
+      false
+    end
+  end
+  
+  # TODO: how to determine the type of stuff? (text, json, yaml, image, video, photo, pdf, generic download file (can lookup type of file for icon if needed))
+  def import(stuff, type = :text)
+    importer = Kernel.const_get(type.to_s.camel_case+'Importer').new(self.class)
+    
+    # The result sent back by an importer is either:
+    #   Array:
+    #     [{ :one => 'stuff' }, { :two => 'stuff' }]
+    #   Hash:
+    #     { :one => 'stuff', :two => 'stuff' }
+    result = importer.import(stuff) 
+    
+    case result
+    when Array
+      commit_array(result)
+    when Hash
+      commit_hash(result)
+    end
+  end
+  
+  def commit_hash(pairs_hash)
+    pairs_hash.each do |key, value|
+      set_attr(key, value)
+    end
+  end
+  
+  def commit_array(pairs_array)
+    pairs_array.each do |pairs_hash|
+      commit_hash(pairs_hash)
+    end
+  end
+
+  def eval_defaults
+    if valid?
+      self.class.defaults_blocks.each do |key, block|
+        set_default(key, self.instance_eval(&block))
+      end
+    end
+  end
+
+  def eval_specials
+    self.class.specials_blocks.each do |key, block|
+      unless get_attr(key).blank?
+        set_attr(key, block.call(get_attr(key)))
+      end
+    end
+  end
+
+  def parse_tags
+    if get_attr(:tags).class == String
+      tags_array = get_attr(:tags).split(',').collect { |t| t.strip }
+      set_attr(:tags, tags_array)
+    end
+  end
+
+  def sanitize_content_fields
+    @content.reject! { |key, value| !self.class.allowed_fields_list.include?(key) }
+  end
+
+  def send_to_storage # send to the db or whatever
+    false
+  end
+
+  def slug_is_unique # validate uniqueness
+    true
+  end
+
+  def fill_default_fields
+    set_default(:published_at, Time.now.utc)
+    set_default(:status, default_status)
+  end
+
+  def generate_slug # OPTIMIZE: this slug generation is ugly
+    result = ''
+  
+    unless self.class.always_use_uuid
+      result = get_attr(self.class.heading_field, false).to_s.dup unless self.class.heading_field.blank?
+  
+      if result.blank?
+        result = get_attr(self.class.primary_field, false).to_s.dup unless self.class.primary_field.blank?
+      end
+  
+      if result.blank?
+        self.class.required_fields_list.each do |required_field|
+          unless get_attr(required_field).blank?
+            result = get_attr(required_field).to_s.dup
+            break
+          end#of unless
+        end#of each
+      end#of if
+  
+      result.slugify!
+    end#of unless
+  
+    if result.blank?
+      result = uuid
+    end
+  
+    set_attr(:slug, result)
+  end
+
+  def truncate_slug(letter_count = 50)
+    unless get_attr(:slug).blank?
+      new_slug = get_attr(:slug).gsub(/^(.{#{letter_count}})(.*)/) { $1.slugify }
+      set_attr(:slug, new_slug)
+    end
+  end
+
+  def default_status
+    :published
+  end
+
+  def post_to_trackbacks
+    false
+  end
+
+  def uuid
+    UUID.timestamp_create.to_s
+  end
+  
+end

data/lib/types/article.rb

@@ -0,0 +1,10 @@
+class Article < PostType
+  fields :title, :body, :category
+  required :body
+  primary :body
+  heading :title
+  
+  def self.detect?(text)
+    true # it can always be an article, so make this last in the preferred order
+  end
+end

data/lib/types/audio.rb

@@ -0,0 +1,10 @@
+class Audio < PostType
+  fields :audio_url, :title, :description, :embed
+  required :audio_url
+  primary :description
+  heading :title
+  
+  def self.detect?(text)
+    has_required? text
+  end
+end

data/lib/types/chat.rb

@@ -0,0 +1,29 @@
+class Chat < PostType
+  fields :transcript
+  required :transcript
+  
+  # override commit_pairs to make chat transcripts form the Me: pairs stuff
+  def commit_array(pairs_array)
+    transcript = []
+    
+    pairs_array.each do |pairs_hash|
+      
+      pairs_hash.each do |key, value|
+        
+        unless self.class.allowed_fields_list.include?(key)
+          transcript << { key => value }
+        else
+          set_attr(key, value)
+        end
+      end#of each
+      
+    end#of each
+    
+    set_attr(:transcript, transcript)
+    
+  end#of commit_pairs
+  
+  def self.detect?(text)
+    has_one_or_more? text, :me
+  end
+end#of Chat

data/lib/types/link.rb

@@ -0,0 +1,26 @@
+class Link < PostType
+  fields :url, :title, :description
+  required :url
+  primary :description
+  heading :title
+  
+  special :url do |link_content|
+    'http://' + link_content.gsub(/^http:\/\//, '')
+  end
+  
+  default :title do
+    result = ''
+    
+    begin
+      doc = Nokogiri::HTML(open(get_attr(:url)))
+      doc.css('title').each { |t| result = t.content }
+    rescue Exception => e
+    end
+    
+    result
+  end
+  
+  def self.detect?(text)
+    has_required? text
+  end
+end

data/lib/types/photo.rb

@@ -0,0 +1,9 @@
+class Photo < PostType
+  fields :photo_url, :caption, :embed
+  required :photo_url
+  primary :caption
+  
+  def self.detect?(text)
+    has_required? text
+  end
+end

data/lib/types/quote.rb

@@ -0,0 +1,27 @@
+class Quote < PostType
+  fields :quote, :source
+  required :quote
+  primary :quote
+  
+  special :quote do |quote_content|
+    unless (quote_content =~ /^<blockquote/).nil?
+      doc = Nokogiri::HTML(quote_content)
+      doc.css('blockquote').each { |q| quote_content = q.content }
+    else
+      quote_content = ''
+    end
+    quote_content.strip
+  end
+  
+  def self.detect?(text)
+    pairs = get_pairs(text)
+    
+    the_quote = pairs.select { |pair| pair.keys.first == :quote }
+    the_quote = the_quote.first || {}
+    
+    markdown = Markdown.new(the_quote[:quote])
+    quote_html = markdown.to_html.strip
+    
+    !(text =~ /Quote: (.*)/).nil? || !(quote_html =~ /^<blockquote(.+)<\/blockquote>$/m).nil?
+  end
+end

data/lib/types/review.rb

@@ -0,0 +1,14 @@
+class Review < PostType
+  fields :rating, :item, :description
+  required :rating, :item
+  primary :description
+  heading :item
+  
+  special :rating do |rating_content|
+    rating_content.to_f
+  end
+  
+  def self.detect?(text)
+    has_required? text
+  end
+end

data/lib/types/video.rb

@@ -0,0 +1,10 @@
+class Video < PostType
+  fields :video_url, :title, :description, :embed
+  required :video_url
+  primary :description
+  heading :title
+  
+  def self.detect?(text)
+    has_required? text
+  end
+end

data/spec/post_type_spec.rb

@@ -0,0 +1,174 @@
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+
+describe PostType do
+  
+  before do
+    class Yellow; end
+    Object.send(:remove_const, :Yellow)
+  end
+  
+  should "have empty content when new" do
+    PostType.new.content.should == nil
+  end
+  
+  should "have a preferred order array" do
+    PostType.preferred_order.should == [Video, Audio, Photo, Chat, Review, Link, Quote, Article]
+  end
+  
+  should "set fields" do
+    class Yellow < PostType
+      fields :one, :two
+    end
+    
+    Yellow.fields_list.should == [:one, :two]
+  end
+  
+  should "set allowed fields" do
+    class Yellow < PostType
+      fields :one
+      allow :anyone, :noone
+    end
+    
+    Yellow.allowed_fields_list.should == [Yellow::DEFAULT_FIELDS, :one, :anyone, :noone].flatten
+  end
+  
+  should "set required fields" do
+    class Yellow < PostType
+      fields :one, :two, :three
+      required :one, :two
+    end
+    
+    Yellow.required_fields_list.should == [:one, :two] 
+  end
+  
+  should "set primary field" do
+    class Yellow < PostType
+      fields :one, :two
+      primary :one
+    end
+    
+    Yellow.primary_field.should == :one
+  end
+  
+  # should use primary field
+  # should make primary field markdown automatically
+  
+  should "set heading field" do
+    class Yellow < PostType
+      fields :one, :two
+      heading :one
+    end
+    
+    Yellow.heading_field.should == :one
+  end
+  
+  should "use heading field" do
+    class Yellow < PostType
+      fields :one, :two
+      primary :one
+      heading :two
+    end
+    
+    y = Yellow.new "Hello Two
+=========
+
+This will be in One."
+    
+    y.get_attr(:one).should == "<p>This will be in One.</p>"
+    y.get_attr(:two).should == "Hello Two"
+  end
+  
+  should "set special values" do
+    class Yellow < PostType
+      fields :plus_one, :two
+      
+      special :plus_one do |field_value|
+        field_value + 1
+      end
+    end
+    
+    Yellow.specials_blocks[:plus_one].should.not.be.blank?
+  end
+  
+  should "use special values" do
+    class Yellow < PostType
+      fields :one, :two
+      
+      special :one do |field_value|
+        field_value.to_i + 1
+      end
+    end
+    
+    y = Yellow.new "One: 2\n\nhello"
+    
+    y.get_attr(:one).should == 3
+  end
+  
+  should "set default values" do
+    class Yellow < PostType
+      fields :one, :two
+      
+      default(:one) { 1 }
+    end
+    
+    Yellow.defaults_blocks[:one].call.should == 1
+  end
+  
+  should "use default values" do
+    class Yellow < PostType
+      fields :one, :two
+      
+      default :two do
+        2
+      end
+    end
+    
+    y = Yellow.new 'hello'
+    
+    y.get_attr(:two).should == 2
+  end
+  
+  should "use markdown fields" do
+    class Yellow < PostType
+      fields :one, :two
+      markdown :two
+    end
+    
+    Yellow.markdown_fields.should == [:two]
+    Yellow.allowed_fields_list.should == [Yellow::DEFAULT_FIELDS, :one, :two, :two_html].flatten
+  end
+  
+  should "use markdown fields" do
+    class Yellow < PostType
+      fields :one, :two
+      markdown :two
+    end
+    
+    y = Yellow.new "Two: *hahaha*"
+    
+    y.get_attr(:two).should == "<p><em>hahaha</em></p>"
+  end
+  
+  should "allow setting and getting of an attribute of the content" do
+    class Yellow < PostType; end
+    y = Yellow.new 'stuff'
+    y.set_attr(:first, 'woo hoo')
+    y.get_attr(:first).should == 'woo hoo'
+  end
+  
+  should "not keep empty attributes" do 
+    class Yellow < PostType
+      fields :one
+      primary :one
+    end
+    
+    y = Yellow.new 'stuff'
+    y.set_attr(:one, '')
+    y.get_attr(:one).should.be.nil
+  end
+  
+  # should auto_detect ?
+  # should save ?
+  # should generate slug
+  
+end

data/spec/post_types/chat_spec.rb

@@ -0,0 +1,25 @@
+require File.join(File.dirname(__FILE__), '../spec_helper.rb')
+
+describe Chat do
+  
+  before do
+    @good_chat = "You: Hello\nMe: Hello back at ya!\nYou: Wanna go eat\nYou: Somehwere\nMe: Yes!"
+    @bad_chat = "Rating: 4\nItem: Dyson\n\nThis should be the description."
+    
+    class Yellow; end
+    Object.send(:remove_const, :Yellow)
+  end
+  
+  should "detect a well-formed chat" do
+    Chat.detect?(@good_chat).should.be.true
+  end
+  
+  should "not detect a malformed chat" do
+    Chat.detect?(@bad_chat).should.be.false
+  end
+  
+  should "autodetect a well-formed chat" do
+    PostType.auto_detect(@good_chat).should.be.kind_of Chat
+  end
+  
+end

data/spec/post_types/link_spec.rb

@@ -0,0 +1,25 @@
+require File.join(File.dirname(__FILE__), '../spec_helper.rb')
+
+describe Link do
+  
+  before do
+    @good_link = "URL: google.com\n\nThis should be the description."
+    @bad_link = "Rating: 4\nItem: Dyson\n\nThis should be the description."
+    
+    class Yellow; end
+    Object.send(:remove_const, :Yellow)
+  end
+  
+  should "detect a well-formed link" do
+    Link.detect?(@good_link).should.be.true
+  end
+  
+  should "not detect a malformed link" do
+    Link.detect?(@bad_link).should.be.false
+  end
+  
+  should "autodetect a well-formed link" do
+    PostType.auto_detect(@good_link).should.be.kind_of Link
+  end
+  
+end

data/spec/post_types/quote_spec.rb

@@ -0,0 +1,35 @@
+require File.join(File.dirname(__FILE__), '../spec_helper.rb')
+
+describe Quote do
+  
+  before do
+    @good_quote = ">    This should be a quote."
+    @good_quote_with_source = "Source: George Washington\n\n>    This is what he said."
+    @good_quote_all_pairs = "Quote: Hello\nSource: Me"
+    @bad_quote = "Rating: 4\nItem: Dyson\n\nThis should be the description."
+    
+    class Yellow; end
+    Object.send(:remove_const, :Yellow)
+  end
+  
+  should "detect a well-formed quote through markdown" do
+    Quote.detect?(@good_quote).should.be.true
+  end
+  
+  should "detect a well-formed quote with source" do
+    Quote.detect?(@good_quote_with_source).should.be.true
+  end
+  
+  should "detect a well-formed quote if it's all pairs" do
+    Quote.detect?(@good_quote_all_pairs).should.be.true
+  end
+  
+  should "not detect a malformed quote" do
+    Quote.detect?(@bad_quote).should.be.false
+  end
+  
+  should "autodetect a well-formed quote" do
+    PostType.auto_detect(@good_quote).should.be.kind_of Quote
+  end
+  
+end

data/spec/post_types/review_spec.rb

@@ -0,0 +1,30 @@
+require File.join(File.dirname(__FILE__), '../spec_helper.rb')
+
+describe Review do
+  
+  before do
+    @good_review = "Rating: 4\nItem: Dyson\n\nThis should be the description."
+    @bad_review = "You: Hello\nMe: Hello back at ya!\nYou: Wanna go eat\nYou: Somehwere\nMe: Yes!"
+    @almost_good_review = "Rating: 4\n\nThis should be the description."
+    
+    class Yellow; end
+    Object.send(:remove_const, :Yellow)
+  end
+  
+  should "detect a well-formed review" do
+    Review.detect?(@good_review).should.be.true
+  end
+  
+  should "not detect a malformed review" do
+    Review.detect?(@bad_review).should.be.false
+  end
+  
+  should "not detect an almost good review" do
+    Review.detect?(@almost_good_review).should.be.false
+  end
+  
+  should "autodetect a well-formed review" do
+    PostType.auto_detect(@good_review).should.be.kind_of Review
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,60 @@
+require "rubygems"
+require 'bacon'
+require 'mocha'
+
+require File.expand_path(File.join(__FILE__.split('/spec').first, 'turbine-core.rb'))
+
+PostType.preferred_order = [Video, Audio, Photo, Chat, Review, Link, Quote, Article]
+
+### run specs with `bacon spec/**/*.rb spec/*.rb`
+
+
+
+# from 1 to 10 how likely, 1 being not very likely and 10 being all the time
+def do_i?(i = 5)
+  rand(500) < 50 * i
+end
+
+
+
+
+##
+# Hash additions.
+#
+# From 
+#   * http://wincent.com/knowledge-base/Fixtures_considered_harmful%3F
+#   * Neil Rahilly
+
+class Hash
+
+  ##
+  # Filter keys out of a Hash.
+  #
+  #   { :a => 1, :b => 2, :c => 3 }.except(:a)
+  #   => { :b => 2, :c => 3 }
+
+  def except(*keys)
+    self.reject { |k,v| keys.include?(k || k.to_sym) }
+  end
+
+  ##
+  # Override some keys.
+  #
+  #   { :a => 1, :b => 2, :c => 3 }.with(:a => 4)
+  #   => { :a => 4, :b => 2, :c => 3 }
+  
+  def with(overrides = {})
+    self.merge overrides
+  end
+
+  ##
+  # Returns a Hash with only the pairs identified by +keys+.
+  #
+  #   { :a => 1, :b => 2, :c => 3 }.only(:a)
+  #   => { :a => 1 }
+  
+  def only(*keys)
+    self.reject { |k,v| !keys.include?(k || k.to_sym) }
+  end
+
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: myobie-turbine-core
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Nathan Herald
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-12 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: TODO
+email: nathan@myobie.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- Rakefile
+- VERSION.yml
+- lib/ext.rb
+- lib/importers/json_importer.rb
+- lib/importers/text_importer.rb
+- lib/post_type.rb
+- lib/types/article.rb
+- lib/types/audio.rb
+- lib/types/chat.rb
+- lib/types/link.rb
+- lib/types/photo.rb
+- lib/types/quote.rb
+- lib/types/review.rb
+- lib/types/video.rb
+- spec/post_type_spec.rb
+- spec/post_types/chat_spec.rb
+- spec/post_types/link_spec.rb
+- spec/post_types/quote_spec.rb
+- spec/post_types/review_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- README
+has_rdoc: true
+homepage: http://github.com/myobie/turbine-core
+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.2.0
+signing_key: 
+specification_version: 2
+summary: TODO
+test_files: 
+- spec/post_type_spec.rb
+- spec/post_types/chat_spec.rb
+- spec/post_types/link_spec.rb
+- spec/post_types/quote_spec.rb
+- spec/post_types/review_spec.rb
+- spec/spec_helper.rb