orthor 0.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Robotic Foo
+
+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/README.md

@@ -0,0 +1,109 @@
+# Orthor Client
+
+The Orthor gem is used to fetch and display your content from orthor.com
+
+## Installation
+
+Is easy
+
+    gem install orthor
+
+## Configuration
+
+Add the below to a file and require it:
+
+    Orthor.setup do
+      account "orthor"     # your orthor account id
+      caching :memory, 600 # cache content in memory for 10 minutes
+    end
+
+You can specify any Moneta cache store class name, e.g. basic_file, memcache etc. The (optional) second argument is cache expiry in seconds, you can provide any initialize options you want as the 3rd arg, e.g.:
+
+    Orthor.setup do
+      account "bob"
+      caching :basic_file, 300, :path => "tmp/"
+    end
+
+## Usage
+
+The first argument to all these methods is the orthor-id of your piece of content/category etc. The second argument is the name of a template (see below) to use to render the returned content.
+
+If you do not provide a template_name to render your content with, you will get the parsed JSON back.
+
+### Content
+
+    Orthor.content("id", :template_name)
+
+### Queries
+
+    Orthor.query("id", :template_name)
+
+### Categories
+
+    Orthor.category("id", :template_name)
+
+### Feeds
+
+    Orthor.feed("id")
+
+## Templates
+
+Orthor returns all of your content in JSON so to make the job of translating JSON -> HTML, we provide some templating help:
+
+    Orthor::Templates.define do
+      template :basic_content, %(<div>{{Content}}</div>)
+
+      template :blog_entry, %(
+        <div class="blog-entry">
+          <h2>{{Title}}</h2>
+          <div class="blog-content">{{Wysiwyg}}</div>
+        </div>)
+      template :blog_entry_brief, %(
+        <div class="blog-entry">
+          <h2><a href="{{URL}}">{{Title}}</a></h2>
+          <p>{{Published on}}</p>
+          <div class="blog-content">{{Wysiwyg.blurb}}</div>
+        </div>)
+
+      template :user_manual, %(
+        <div class="user-manual-entry">
+          <h2>{{Title}}</h2>
+          <p class="last-updated">Last updated: {{Updated on}}</p>
+          <div class="content">{{Wysiwyg}}</div>
+        </div>)
+    end
+
+Now any call you make to Orthor.content/category/query can be given a 2nd argument of a template name and rather than receiving parsed JSON, you will be returned a HTML string.
+
+### Default template tags
+
+These tags are available to all content:
+
+    {{id}}           - the orthor id of your content item
+    {{Title}}        - your content title
+    {{Created on}}   - the date your content was created
+    {{Updated on}}   - the date your content was last updated
+    {{Author}}       - a hash of the original authors details
+    {{Updater}}      - a hash of the updater details
+    {{Published on}} - the date your content was published
+    {{URL}}          - the URL for your content as defined in Orthor, or auto generated as /:template-prefix/category-id/content-id
+    {{template}}     - the name of the template this content was created from
+    {{category}}     - a hash of this items category details
+
+Other attributes that will be present on a per item specific basis are are the names of your template elements, e.g.
+
+    {{Content}}
+    {{Featured News Item}}
+    {{Supporting Image}}
+    {{Markdown body}}
+
+## Questions? Comments?
+
+anthony@orthor.com
+
+## Examples
+
+[Orthor demo site](http://github.com/anthony/orthor-demo)
+
+Copyright (c) 2009 Robotic Foo, released under the MIT license
+

data/lib/orthor.rb

@@ -0,0 +1,90 @@
+require 'moneta'
+require 'json'
+
+require 'orthor/templates'
+
+class Orthor
+  class << self
+    attr_accessor :cache, :cache_expiry, :account_id
+  end
+
+  def self.content(id, template = nil)
+    Templates.render(get(:content_items, id), template)
+  end
+
+  def self.query(id, template = nil)
+    Templates.render(get(:queries, id), template)
+  end
+
+  def self.category(id, template = nil)
+    Templates.render(get(:categories, id), template)
+  end
+
+  def self.feed(id)
+    get(:feeds, id)
+  end
+
+  def self.render(items, template)
+    Templates.render(items, template)
+  end
+
+  def self.caching(file, expiry = nil, options = {})
+    expiry, options = nil, expiry if expiry.is_a?(Hash)
+
+    klass = file.to_s.split('_').collect { |e| e.capitalize }.join
+    Moneta.autoload(klass.to_sym, "moneta/#{file}")
+    self.cache = Moneta.const_get(klass).new(options)
+    self.cache_expiry = expiry
+  end
+
+  def self.account(id)
+    self.account_id = id
+  end
+
+  def self.setup(&block)
+    raise ArgumentError unless block_given?
+    self.cache = false # default
+
+    class_eval &block
+  end
+
+private
+  def self.get(type, id)
+    raise "No orthor account given... Please add one to your Orthor setup block" unless account_id
+
+    begin
+      suffix = type == :feeds ? "rss" : "json"
+      key = "#{id}-#{type}"
+      url = "http://content.orthor.com/#{account_id}/#{type}/#{id}.#{suffix}"
+
+      resp = cache ? get_cached_content(key, url) : get_response(url)
+
+      return resp unless suffix == "json"
+
+      JSON.parse(resp)
+    rescue => e
+      return ""
+    end
+  end
+
+  def self.get_cached_content(id, url)
+    content = cache[id]
+    if content.nil? || content.empty?
+      content = get_response(url)
+
+      options = {}
+      options[:expires_in] = cache_expiry if cache_expiry
+      cache.store(id, content, options) unless content.empty?
+    end
+    content
+  end
+
+  def self.get_response(uri)
+    r = Net::HTTP.get_response(URI.parse(uri))
+    r.code.to_i == 200 ? r.body : ""
+  rescue => e
+    ""
+  end
+
+  private_class_method :get, :get_cached_content, :get_response
+end

data/lib/orthor/templates.rb

@@ -0,0 +1,89 @@
+class Orthor
+  class Templates
+    class Unknown < StandardError; end
+
+    class << self
+      attr_accessor :templates, :mappings
+    end
+
+    def self.define(&blk)
+      self.templates, self.mappings = {}, {}
+      class_eval &blk
+    end
+
+    def self.template(name, markup)
+      self.templates[name.to_s] = markup
+    end
+
+    def self.mapping(name, map)
+      self.mappings[name] = map
+    end
+
+    def self.[](key)
+      self.templates ||= {}
+      self.templates[key.to_s]
+    end
+
+    def self.render(items, template_name_or_mapping)
+      return items unless template_name_or_mapping
+
+      items = [items] unless items.is_a?(Array)
+      items.inject("") do |html, item|
+        html += parse(item, template_name_or_mapping)
+      end
+    end
+
+  private
+    def self.parse(item, template_name_or_mapping)
+      # ensure we're dealing with an array
+      unless item.is_a?(Array)
+        if item["type"] == "category"
+          item = item["content"]
+        else
+          item = [item]
+        end
+      end
+
+      item.collect do |c|
+        markup = template_for(c, template_name_or_mapping)
+
+        c.inject(markup) do |html, (key, val)|
+          if val.is_a?(String) && html.include?("{{#{key}.blurb}}")
+            val = "#{val.to_s.gsub(/<\/?[^>]*>/, "")[0..150]}..."
+            key = "#{key}.blurb"
+
+            html = html.gsub("{{#{key}}}", val.to_s)
+          elsif val.is_a?(Hash) && html.include?("{{#{key}.")
+            # we've got something like Author.Email
+            html = val.inject(html) { |h, (k, v)| h = h.gsub("{{#{key}.#{k}}}", v.to_s) }
+          else
+            html = html.gsub("{{#{key}}}", val.to_s)
+          end
+        end
+      end.join("")
+    rescue => e
+      raise e if e.is_a?(Orthor::Templates::Unknown)
+      return ""
+    end
+
+    def self.template_for(item, template_name_or_mapping)
+      if [String, Symbol].include?(template_name_or_mapping.class)
+        markup = self[template_name_or_mapping]
+
+        if !markup && self.mappings[template_name_or_mapping]
+          # we've actually got a named mapping
+          markup = self[self.mappings[template_name_or_mapping][item["template"]]]
+        else
+          raise Unknown, "Could not find template #{template_name_or_mapping}" unless markup
+        end
+      end
+      if template_name_or_mapping.is_a?(Hash)
+        markup = self[template_name_or_mapping[item["template"]]]
+        raise Unknown, "Could not find template mapping for #{item["template"]}" unless markup
+      end
+      markup
+    end
+
+    private_class_method :parse, :template_for
+  end
+end

data/spec/orthor/templates_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+describe Orthor::Templates do
+  before(:all) do
+    FakeWeb.register_uri(:get, "http://content.orthor.com/orthor/content_items/content.json",
+                         :body => File.join(SPEC_DIR, 'resources', 'content.json'))
+    FakeWeb.register_uri(:get, "http://content.orthor.com/orthor/queries/query.json",
+                         :body => File.join(SPEC_DIR, 'resources', 'query.json'))
+    FakeWeb.register_uri(:get, "http://content.orthor.com/orthor/categories/category.json",
+                         :body => File.join(SPEC_DIR, 'resources', 'category.json'))
+    FakeWeb.register_uri(:get, "http://content.orthor.com/orthor/categories/varied.json",
+                         :body => File.join(SPEC_DIR, 'resources', 'varied_content.json'))
+    FakeWeb.register_uri(:get, "http://content.orthor.com/orthor/feeds/feed.rss",
+                         :body => File.join(SPEC_DIR, 'resources', 'feed.rss'))
+    FakeWeb.register_uri(:get, "http://content.orthor.com/orthor/content_items/missing.json",
+                         :body => "")
+
+    Orthor.setup do
+      account "orthor"
+    end
+
+    Orthor::Templates.define do
+      template :basic, %!<h2>{{Title}}</h2><div class="content">{{Content}}</div>!
+      template :brief, %!<h2>{{Title}}</h2>!
+      template :blurb, %!<div>{{Content.blurb}}</div>!
+      template :user, %!<div>{{Creator.Email}}</div><div>{{Creator.First name}} {{Creator.Last name}}</div>!
+
+      mapping :listing, { "Text Block" => :brief }
+    end
+  end
+
+  describe "with no content returned" do
+    it "should return an empty string" do
+      Orthor.content("missing").should be_empty
+    end
+  end
+
+  describe "defining a set of templates" do
+    it "should store the defined templates" do
+      Orthor::Templates.templates.length.should == 4
+    end
+
+    it "should return templates by name" do
+      Orthor::Templates[:basic].should == %!<h2>{{Title}}</h2><div class="content">{{Content}}</div>!
+    end
+  end
+
+  describe "nested attributes" do
+    it "should support User.Email, User.First name, User.Last name" do
+      Orthor.content("content", :user).should == "<div>demo@orthor.com</div><div>Bob Demo</div>"
+    end
+  end
+
+  describe "a content item" do
+    it "should display content using the named template" do
+      Orthor.content("content", :basic).should == %!<h2>What is Orthor</h2><div class="content"><h2>So what is Orthor really??</h2></div>!
+    end
+
+    it "should respect given template name" do
+      Orthor.content("content", :brief).should == %!<h2>What is Orthor</h2>!
+    end
+
+    describe "blurb" do
+      it "should truncate some of the text, strip html and add ..." do
+        Orthor.content("content", :blurb).should == "<div>So what is Orthor really??...</div>"
+      end
+    end
+  end
+
+  describe "a content query" do
+    it "should render the template for each item" do
+      Orthor.query("query", :brief).should == %!<h2>User Manual updated</h2><h2>Account event tracking</h2><h2>Tutorials have been updated</h2>!
+    end
+  end
+
+  describe "a category" do
+    it "should render the template for each item" do
+      Orthor.category("category", :brief).should == %!<h2>User Manual updated</h2><h2>Account event tracking</h2><h2>Tutorials have been updated</h2><h2>Content Queries have landed in Orthor</h2>!
+    end
+  end
+
+  describe "rendering given a hash/array" do
+    before(:all) do
+      @json = Orthor.category("category")
+    end
+
+    it "should be able to render an array of items" do
+      Orthor.render(@json["content"], :brief).should == "<h2>User Manual updated</h2><h2>Account event tracking</h2><h2>Tutorials have been updated</h2><h2>Content Queries have landed in Orthor</h2>"
+    end
+
+    it "should be able to render an individual hash" do
+      Orthor.render(@json["content"].first, :brief).should == "<h2>User Manual updated</h2>"
+    end
+  end
+
+  describe "with a non-existant template" do
+    it "should raise an error" do
+      lambda { Orthor.category("category", :blah) }.should raise_error(Orthor::Templates::Unknown)
+    end
+  end
+
+  describe "template mapping" do
+    before(:all) do
+      @json = Orthor.category("varied")
+    end
+
+    it "should allow you to pass a hash of orthor template names" do
+      Orthor.render(@json["content"], { "Brief News Item" => :basic, "Link" => :brief, "Bookmark" => :blurb }).should == "<h2>User Manual updated</h2><div class=\"content\">The User Manual has recently had a big overhaul with increased documentation for lots of Orthor's great features, including Content Queries, RSS Feeds, Custom CSS and more!</div><div>All accounts now have access to event tracking, use this to gain a snapshot of what everyone in your account has been doing, for example, what were the...</div><h2>Tutorials have been updated</h2><div class=\"content\">We've recently made the tutorials section of the site public, stay tuned for some more language examples + increased detail of the existing languages. </div><h2>Content Queries have landed in Orthor</h2>"
+    end
+
+    describe "with a named map" do
+      it "should find the template from the map" do
+        Orthor.content("content", :listing).should == "<h2>What is Orthor</h2>"
+      end
+    end
+
+    describe "when a mapping is missing" do
+      it "should raise an Unknown template exception" do
+        lambda do
+          Orthor.render(@json["content"], { "Brief News Item" => :basic, "Link" => :brief })
+        end.should raise_error(Orthor::Templates::Unknown)
+      end
+    end
+  end
+end

data/spec/orthor_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+describe Orthor do
+  before(:all) do
+    FakeWeb.register_uri(:get, "http://content.orthor.com/orthor/content_items/content.json",
+                         :body => File.join(SPEC_DIR, 'resources', 'content.json'))
+    FakeWeb.register_uri(:get, "http://content.orthor.com/orthor/queries/query.json",
+                         :body => File.join(SPEC_DIR, 'resources', 'query.json'))
+    FakeWeb.register_uri(:get, "http://content.orthor.com/orthor/categories/category.json",
+                         :body => File.join(SPEC_DIR, 'resources', 'category.json'))
+    FakeWeb.register_uri(:get, "http://content.orthor.com/orthor/feeds/feed.rss",
+                         :body => File.join(SPEC_DIR, 'resources', 'feed.rss'))
+  end
+
+  describe "setup" do
+    before(:all) do
+      Orthor.setup do
+        account nil
+      end
+    end
+
+    it "should raise an error if no account id is present" do
+      lambda { Orthor.content("content") }.should raise_error
+    end
+  end
+
+  describe "getting" do
+    before(:all) do
+      Orthor.setup do
+        account "orthor"
+      end
+    end
+
+    it "should return a Hash for a content item" do
+      Orthor.content("content").should be_a(Hash)
+    end
+
+    it "should return an array for a query" do
+      Orthor.query("query").should be_an(Array)
+    end
+
+    it "should return a hash for a category" do
+      Orthor.category("category").should be_a(Hash)
+    end
+
+    it "should return a string for a feed" do
+      Orthor.feed("feed").should be_a(String)
+    end
+
+    it 'should be able to fetch content items' do
+      Orthor.content("content").to_s.should include("<h2>So what is Orthor really??</h2>")
+    end
+
+    it 'should be able to fetch queries' do
+      Orthor.query("query").to_s.should include("big overhaul with increased documentation for lots of")
+    end
+
+    it 'should be able to fetch categories' do
+      Orthor.category("category").to_s.should include("The User Manual has recently had a big overhaul")
+    end
+  end
+
+  describe "caching" do
+    describe "no config" do
+      before(:all) do
+        Orthor.setup do
+          account "orthor"
+        end
+      end
+
+      it 'should not cache content if no config is given' do
+        Orthor.cache.should == false
+      end
+    end
+
+    describe "with config" do
+      describe "memory" do
+        before(:all) do
+          Orthor.setup do
+            account "orthor"
+            caching :memory, 600
+          end
+        end
+
+        it "should create a moneta cache class" do
+          Orthor.cache.should be_a(Moneta::Memory)
+        end
+
+        it "should set a cache expiry" do
+          Orthor.cache_expiry.should == 600
+        end
+
+        it 'should add content to the cache after requests' do
+          Orthor.cache["content-content_items"].should be_empty
+          Orthor.content("content")
+          Orthor.cache["content-content_items"].should_not be_empty
+
+          Orthor.should_not_receive(:cache_content)
+          Orthor.content("content")
+        end
+      end
+
+      describe "basic file store" do
+        before(:all) do
+          Orthor.setup do
+            account "orthor"
+            caching :basic_file, 300, :path => "tmp/"
+          end
+        end
+
+        it "should create a moneta basic file cache class" do
+          Orthor.cache.should be_a(Moneta::BasicFile)
+        end
+      end
+
+      describe "optinal expiry time argument" do
+        before(:all) do
+          Orthor.setup do
+            account "orthor"
+            caching :basic_file, :path => "tmp/"
+          end
+        end
+
+        it "should default to no cache expiry" do
+          Orthor.cache_expiry.should be_nil
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'spec'
+require 'fake_web'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'orthor')
+
+SPEC_DIR = File.dirname(__FILE__) unless defined? SPEC_DIR

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+name: orthor
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Anthony Langhorne
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-10 00:00:00 +10:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  name: moneta
+  prerelease: false
+  requirement: *id001
+  type: :runtime
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  name: json
+  prerelease: false
+  requirement: *id002
+  type: :runtime
+description: 
+email: anthony@orthor.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- lib/orthor.rb
+- lib/orthor/templates.rb
+- LICENSE
+- README.md
+has_rdoc: true
+homepage: http://github.com/anthony/orthor-client
+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 gem for displaying content from orthor.com
+test_files: 
+- spec/orthor/templates_spec.rb
+- spec/orthor_spec.rb
+- spec/spec_helper.rb