copy 0.0.1

data/lib/copy/server.rb

@@ -0,0 +1,118 @@
+require 'sinatra/base'
+require 'erb'
+require 'redcarpet'
+
+module Copy 
+  class Server < Sinatra::Base    
+    set :views,  './views'
+    set :public, './public'
+    set :root, File.dirname(File.expand_path(__FILE__))
+    
+    helpers do
+      def protected!
+        unless authorized?
+          response['WWW-Authenticate'] = %(Basic realm="Copy Admin Area")
+          throw(:halt, [401, "Not authorized\n"])
+        end
+      end
+
+      def authorized?
+        return false unless settings.respond_to?(:admin_user) && settings.respond_to?(:admin_password)
+        @auth ||=  Rack::Auth::Basic::Request.new(request.env)
+        @auth.provided? && @auth.basic? && @auth.credentials && @auth.credentials == [settings.admin_user, settings.admin_password]
+      end
+      
+      def set_cache_control_header
+        if settings.respond_to?(:cache_time) && settings.cache_time.is_a?(Numeric) && settings.cache_time > 0
+          expires settings.cache_time, :public
+        else
+          cache_control :no_cache
+        end
+      end
+      
+      def format_text(name, content, options = {})
+        original = content.dup
+        # Apply markdown formatting.
+        content = Redcarpet.new(content, :smart).to_html.chomp
+        
+        html_attrs = %Q(class="_copy_editable" data-name="#{name}")
+        
+        if original =~ /\n/ # content with newlines renders in a div
+          tag = options[:wrap_tag] || :div
+          %Q(<#{tag} #{html_attrs}>#{content}</#{tag}>)
+        else # single line content renders in a span without <p> tags
+          tag = options[:wrap_tag] || :span
+          content.gsub!(/<\/*p>/, '')
+          %Q(<#{tag} #{html_attrs}>#{content}</#{tag}>)
+        end
+      end
+      
+      def copy(name, options = {}, &block)
+        if !Copy::Storage.connected? || !(content = Copy::Storage.get(name))
+          # Side-step the output buffer so we can capture the block, but not output it.
+          @_out_buf, old_buffer = '', @_out_buf
+          content = yield
+          @_out_buf = old_buffer
+          
+          # Get the first line from captured text.
+          first_line = content.split("\n").first
+          # Determine how much white space it has in front.
+          white_space = first_line.match(/^(\s)*/)[0]
+          # Remove that same amount of white space from the beginning of every line.
+          content.gsub!(Regexp.new("^#{white_space}"), '')
+          
+          # Save the content so it can be edited.
+          Copy::Storage.set(name, content) if Copy::Storage.connected?
+        end
+        
+        # Append the output buffer.
+        @_out_buf << format_text(name, content, options)
+      end
+    end
+    
+    def self.config(&block)
+      class_eval(&block)
+    end
+    
+    before do
+      if settings.respond_to?(:storage) && !Copy::Storage.connected?
+        Copy::Storage.connect!(settings.storage)
+      end
+    end
+    
+    get '/_copy/?' do
+      protected!
+      ERB.new(File.read(settings.root + '/admin/index.html.erb')).result(self.send(:binding))
+    end
+    
+    get '/_copy.js' do
+      protected!
+      content_type(:js)
+      ERB.new(File.read(settings.root + '/admin/index.js.erb')).result(self.send(:binding))
+    end
+    
+    get '/_copy/:name' do
+      protected!
+      @name = params[:name]
+      @doc = Copy::Storage.get(params[:name])
+      ERB.new(File.read(settings.root + '/admin/edit.html.erb')).result(self.send(:binding))
+    end
+    
+    put '/_copy/:name' do
+      protected!
+      Copy::Storage.set(params[:name], params[:content])
+      format_text(params[:name], Copy::Storage.get(params[:name]), :wrap_tag => params[:wrap_tag])
+    end
+    
+    get '*' do
+      route = Copy::Router.new(params[:splat].first, settings.views)
+      if route.success?
+        set_cache_control_header
+        content_type(route.format)
+        send(route.renderer, route.template, :layout => route.layout)
+      else
+        not_found
+      end
+    end
+  end
+end

data/lib/copy/storage/mongodb.rb

@@ -0,0 +1,39 @@
+require 'mongo'
+require 'uri'
+
+module Copy
+  module Storage
+    class Mongodb
+      def initialize(connection_url)
+        uri         = URI.parse(connection_url)
+        connection  = ::Mongo::Connection.from_uri(connection_url)
+        database    = connection.db(uri.path.gsub(/^\//, ''))
+        
+        @collection = database['copy-content']
+        @collection.ensure_index([['name', Mongo::ASCENDING]], :unique => true)
+        @collection
+      end
+      
+      def get(name)
+        doc = find(name)
+        doc['content'] unless doc.nil?
+      end
+      
+      def set(name, content)
+        doc = find(name)
+        if doc
+          doc['content'] = content
+          @collection.update({ '_id' => doc['_id'] }, doc)
+        else
+          @collection.insert('name' => name, 'content' => content)
+        end
+      end
+      
+      private
+        def find(name)
+          docs = @collection.find('name' => name)
+          docs.first if docs.respond_to?(:first)
+        end
+    end
+  end
+end

data/lib/copy/storage/redis.rb

@@ -0,0 +1,19 @@
+require 'redis'
+
+module Copy
+  module Storage
+    class Redis
+      def initialize(connection_url)
+        @redis = ::Redis.new(connection_url)
+      end
+      
+      def get(name)
+        @redis.hget("copy:content", name)
+      end
+      
+      def set(name, content)
+        @redis.hset("copy:content", name, content)
+      end
+    end
+  end
+end

data/lib/copy/storage/relational.rb

@@ -0,0 +1,37 @@
+require 'data_mapper'
+
+module Copy
+  module Storage
+    class Relational
+      class Document
+        include DataMapper::Resource
+        
+        storage_names[:default] = 'copy_documents'
+    
+        property :id,         Serial
+        property :name,       String, :unique_index => true
+        property :content,    Text
+      end
+      
+      def initialize(connection_url)
+        DataMapper.setup(:default, connection_url)
+        DataMapper.finalize
+        DataMapper.auto_upgrade!
+      end
+      
+      def get(name)
+        doc = Document.first(:name => name)
+        doc.content unless doc.nil?
+      end
+      
+      def set(name, content)
+        doc = Document.first(:name => name)
+        if doc
+          doc.update(:content => content)
+        else
+          Document.create(:name => name, :content => content)
+        end
+      end
+    end
+  end
+end

data/lib/copy/storage.rb

@@ -0,0 +1,30 @@
+require 'uri'
+
+module Copy
+  module Storage
+    autoload :Mongodb,    'copy/storage/mongodb'
+    autoload :Redis,      'copy/storage/redis'
+    autoload :Relational, 'copy/storage/relational'
+    
+    def self.connect!(connection_url)
+      scheme = URI.parse(connection_url).scheme
+      klass  = scheme.capitalize
+      if %w(sqlite mysql postgres).include?(scheme)
+        klass = 'Relational'
+      end
+      @@storage = Copy::Storage.const_get(klass).new(connection_url)
+    end
+    
+    def self.connected?
+      !defined?(@@storage).nil?
+    end
+    
+    def self.get(name)
+      @@storage.get(name.to_s)
+    end
+    
+    def self.set(name, content)
+      @@storage.set(name.to_s, content)
+    end
+  end
+end

data/lib/copy/version.rb

@@ -0,0 +1,3 @@
+module Copy
+  VERSION = '0.0.1'
+end

data/lib/copy.rb

@@ -0,0 +1,6 @@
+module Copy
+  autoload :Router,  'copy/router'
+  autoload :Server,  'copy/server'
+  autoload :Storage, 'copy/storage'
+  autoload :Content, 'copy/content'
+end

data/test/router_test.rb

@@ -0,0 +1,108 @@
+require 'test_helper'
+
+class RouterTest < Test::Unit::TestCase
+  test "format defaults to html" do
+    assert_equal :html, router('/something').format
+    assert_equal :html, router('/a/b/c/').format
+  end
+  
+  test "recognize format in path" do
+    assert_equal :html, router('/something.html').format
+    assert_equal :html, router('/about/something.html').format
+    assert_equal :xml,  router('/index.xml').format
+    assert_equal :csv,  router('/employees.csv').format
+    assert_equal :rss,  router('/news/feed.rss').format
+  end
+  
+  test "find template file" do
+    Dir.expects(:glob).with('./views/about.html*').twice.returns(['./views/about.html.erb'])
+    
+    assert_equal './views/about.html.erb', router('/about', './views').template_file
+    assert_equal './views/about.html.erb', router('/about.html', './views').template_file
+  end
+  
+  test "find template file as index in dir" do
+    Dir.expects(:glob).with('./views/about.html*').returns([])
+    Dir.expects(:glob).with('./views/about/index.html*').returns(['./views/about/index.html.erb'])
+    
+    assert_equal './views/about/index.html.erb', router('/about', './views').template_file
+  end
+  
+  test "find template file as index in dir when path has trailing slash" do
+    Dir.expects(:glob).with('./views/about/us.html*').returns([])
+    Dir.expects(:glob).with('./views/about/us/index.html*').returns(['./views/about/us/index.html.erb'])
+    
+    assert_equal './views/about/us/index.html.erb', router('/about/us/', './views').template_file
+  end
+  
+  test "find template file in dir when path has trailing slash" do
+    Dir.expects(:glob).with('./views/about/us.html*').returns(['./views/about/us.html.erb'])
+    
+    assert_equal './views/about/us.html.erb', router('/about/us/', './views').template_file
+  end
+  
+  test "find index template file when empty path given" do
+    Dir.expects(:glob).with('./views/index.html*').returns(['./views/index.html.erb'])
+    
+    assert_equal './views/index.html.erb', router('/', './views').template_file
+  end
+  
+  test "renderer determined from template file extension" do
+    r1 = router('/about')
+    r1.expects(:template_file).returns('about.html.erb')
+    assert_equal :erb, r1.renderer
+    
+    r2 = router('/about')
+    r2.expects(:template_file).returns('about.html.haml')
+    assert_equal :haml, r2.renderer
+  end
+  
+  test "template determined from template file" do
+    r1 = router('/about', './views')
+    r1.expects(:template_file).at_least_once.returns('./views/about.html.erb')
+    assert_equal :'about.html', r1.template
+    
+    r2 = router('/about/nothing.html', './views')
+    r2.expects(:template_file).at_least_once.returns('./views/about/nothing.html.erb')
+    assert_equal :'about/nothing.html', r2.template
+  end
+  
+  test "layout for html format and presense of layout file" do
+    r = router('/about', './views')
+    r.expects(:template_file).returns('./views/about.html.erb')
+    File.expects(:exists?).with('./views/layout.html.erb').returns(true)
+    
+    assert_equal :'layout.html', r.layout
+  end
+  
+  test "layout is false when no layout file is found" do
+    r = router('/about', './views')
+    r.expects(:template_file).returns('./views/about.html.erb')
+    File.expects(:exists?).with('./views/layout.html.erb').returns(false)
+    
+    assert_equal false, r.layout
+  end
+  
+  test "layout is false with non-html format" do
+    r = router('/people.csv', './views')
+    assert_equal false, r.layout
+  end
+  
+  test "success when template file found" do
+    Dir.expects(:glob).with('./views/about.html*').returns(['./views/about.html.erb'])
+    
+    assert router('/about', './views').success?
+  end
+  
+  test "no success when template file not found" do
+    Dir.expects(:glob).with('./views/about.html*').returns([])
+    Dir.expects(:glob).with('./views/about/index.html*').returns([])
+    
+    assert !router('/about', './views').success?
+  end
+
+  private
+    def router(path, views = '')
+      Copy::Router.new(path, views)
+    end
+end

data/test/server_test.rb

@@ -0,0 +1,167 @@
+require 'test_helper'
+require 'rack/test'
+
+class ServerTest < Test::Unit::TestCase
+  include CopyAppSetup
+  include Rack::Test::Methods
+  
+  test "GET index" do
+    get '/'
+    
+    assert last_response.ok?
+    assert_equal 'text/html;charset=utf-8', last_response.headers['Content-Type']
+    assert_match "<title>I'm the layout!</title>", last_response.body
+    assert_match "<p>I'm the index!</p>", last_response.body
+  end
+  
+  test "GET path with index in folder" do
+    %w(/about /about/).each do |path|
+      get path
+      
+      assert last_response.ok?
+      assert_match "<p>About!</p>", last_response.body
+    end
+  end
+  
+  test "GET path to template in folder" do
+    %w(/about/us /about/us/).each do |path|
+      get path
+      
+      assert last_response.ok?
+      assert_match "<p>About us!</p>", last_response.body
+    end
+  end
+  
+  test "GET non-existent path" do
+    get '/nope'
+    assert last_response.status == 404
+  end
+  
+  test "cache_time setting sets a Cache-Control header" do
+    app.config { set :cache_time, 456 }
+    get '/'
+    assert_equal 'public, max-age=456', last_response.headers['Cache-Control']
+    
+    [0, nil, false].each do |time|
+      app.config { set :cache_time, time }
+      get '/'
+      assert_equal 'no-cache', last_response.headers['Cache-Control']
+    end
+  end
+  
+  test "GET csv" do
+    get 'data/people.csv'
+    
+    assert last_response.ok?
+    assert_equal 'text/csv;charset=utf-8', last_response.headers['Content-Type']
+    assert_equal File.read(app.settings.views + '/data/people.csv.erb'), last_response.body
+  end
+  
+  test "GET xml" do
+    get 'data/people.xml'
+    
+    assert last_response.ok?
+    assert_equal 'application/xml;charset=utf-8', last_response.headers['Content-Type']
+    assert_equal File.read(app.settings.views + '/data/people.xml.erb'), last_response.body
+  end
+  
+  test "connects to storage when setting present" do
+    connection_url = 'redis://localhost:1234'
+    app.config { set :storage, connection_url }
+    Copy::Storage.expects(:connect!).with(connection_url).once.returns(true)
+    get '/'
+    assert last_response.ok?
+  end
+end
+
+class ServerCopyHelperTest < Test::Unit::TestCase
+  include CopyAppSetup
+  include Rack::Test::Methods
+  
+  test "copy helper displays content from storage" do
+    Copy::Storage.stubs(:connected?).returns(true)
+    Copy::Storage.expects(:get).with(:facts).returns("truth")
+    
+    get 'with_copy_helper'
+    assert last_response.ok?
+    assert_match "truth", last_response.body
+  end
+  
+  test "copy helper saves defaults text when content is not in storage and renders it" do
+    Copy::Storage.stubs(:connected?).returns(true)
+    Copy::Storage.expects(:get).with(:facts).returns(nil)
+    Copy::Storage.expects(:set).with(:facts, "_Default Text_\n").returns(true)
+    
+    get 'with_copy_helper'
+    assert last_response.ok?, last_response.errors
+    assert_match %Q(<div class="_copy_editable" data-name="facts"><p><em>Default Text</em></p></div>), last_response.body
+  end
+  
+  test "copy helper shows default text when not connected" do
+    Copy::Storage.expects(:connected?).twice.returns(false)
+    
+    get 'with_copy_helper'
+    assert last_response.ok?
+    assert_match %Q(<div class="_copy_editable" data-name="facts"><p><em>Default Text</em></p></div>), last_response.body
+  end
+  
+  test "copy helper renders single line content correctly" do
+    Copy::Storage.expects(:connected?).twice.returns(false)
+    
+    get 'with_copy_helper_one_line'
+    assert last_response.ok?
+    assert_match %Q(<span class="_copy_editable" data-name="headline">Important!</span>), last_response.body
+  end
+end
+
+class ServerAdminTest < Test::Unit::TestCase
+  include CopyAppSetup
+  include Rack::Test::Methods
+  
+  test "GET /_copy is protected when no user/pass are set" do
+    get '/_copy'
+    assert_equal 401, last_response.status
+  end
+  
+  test "GET /_copy protected when user/pass are set, but supplied incorrectly" do
+    setup_auth 'good', 'girl'
+    authorize 'bad', 'boy'
+    get '/_copy'
+    assert_equal 401, last_response.status
+  end
+  
+  test "GET /_copy with valid credentials" do
+    authorize!
+    get '/_copy'
+    assert last_response.ok?
+    assert_match 'Edit Copy', last_response.body
+  end
+  
+  test "GET /_copy.js" do
+    authorize!
+    get '/_copy.js'
+    assert last_response.ok?, last_response.errors
+    assert_match 'jQuery JavaScript Library', last_response.body
+  end
+  
+  test "GET /_copy/:name" do
+    Copy::Storage.stubs(:connected?).returns(true)
+    Copy::Storage.expects(:get).with('fun').returns('party')
+    
+    authorize!
+    get '/_copy/fun'
+    assert last_response.ok?, last_response.errors
+    assert_match "party</textarea>", last_response.body
+  end
+  
+  test "PUT /_copy/:name" do
+    Copy::Storage.stubs(:connected?).returns(true)
+    Copy::Storage.expects(:set).with('fun', '_party_').returns(true)
+    Copy::Storage.expects(:get).with('fun').returns('_party_')
+    
+    authorize!
+    put '/_copy/fun', :content => '_party_', :wrap_tag => 'article'
+    assert last_response.ok?, last_response.errors
+    assert_match %Q(<article class="_copy_editable" data-name="fun"><em>party</em></article>), last_response.body
+  end
+end

data/test/storage_test.rb

@@ -0,0 +1,50 @@
+require 'test_helper'
+
+# Maybe TODO: Should the tests require a running redis, mongo, mysql
+# instance and actually test getting, setting data?
+
+class StorageTest < Test::Unit::TestCase
+  test "mongodb connect!" do
+    connection_url ='mongodb://copy:secret@localhost/copy-content'
+    Copy::Storage::Mongodb.expects(:new).with(connection_url).returns(true)
+    
+    assert Copy::Storage.connect!(connection_url)
+  end
+  
+  test "redis connect!" do
+    connection_url ='redis://localhost:6379'
+    Copy::Storage::Redis.expects(:new).with(connection_url).returns(true)
+    
+    assert Copy::Storage.connect!(connection_url)
+  end
+  
+  test "mysql connect!" do
+    connection_url = 'mysql://localhost/copy_content'
+    Copy::Storage::Relational.expects(:new).with(connection_url).returns(true)
+    
+    assert Copy::Storage.connect!(connection_url)
+  end
+  
+  test "postgres connect!" do
+    connection_url = 'postgres://localhost/copy_content'
+    Copy::Storage::Relational.expects(:new).with(connection_url).returns(true)
+    
+    assert Copy::Storage.connect!(connection_url)
+  end
+  
+  test "sqlite connect!" do
+    connection_url = 'sqlite:///path/to/copy_content.db'
+    Copy::Storage::Relational.expects(:new).with(connection_url).returns(true)
+    
+    assert Copy::Storage.connect!(connection_url)
+  end
+  
+  test "get and set" do
+    connection_url ='redis://localhost:6379'
+    Copy::Storage::Redis.expects(:new).with(connection_url).returns(stub(:get => :result1, :set => :result2))
+    
+    Copy::Storage.connect!(connection_url)
+    assert_equal :result1, Copy::Storage.get('name')
+    assert_equal :result2, Copy::Storage.set('name', 'content')
+  end
+end

data/test/test_app/views/about/index.html.erb

@@ -0,0 +1 @@
+<p>About!</p>

data/test/test_app/views/about/us.html.erb

@@ -0,0 +1 @@
+<p>About us!</p>

data/test/test_app/views/data/people.csv.erb

@@ -0,0 +1 @@
+Javan,Zooey,Nali

data/test/test_app/views/data/people.xml.erb

@@ -0,0 +1 @@
+<person>Javan</person>

data/test/test_app/views/index.html.erb

@@ -0,0 +1 @@
+<p>I'm the index!</p>

data/test/test_app/views/layout.html.erb

@@ -0,0 +1,8 @@
+<html>
+<head>
+  <title>I'm the layout!</title>
+</head>
+<body>
+  <%= yield %>
+</body>
+</html>

data/test/test_app/views/with_copy_helper.html.erb

@@ -0,0 +1,3 @@
+<% copy :facts do %>
+  _Default Text_
+<% end %>

data/test/test_app/views/with_copy_helper_one_line.html.erb

@@ -0,0 +1 @@
+<h1><% copy :headline do %>Important!<% end %></h1>

data/test/test_helper.rb

@@ -0,0 +1,49 @@
+dir = File.dirname(File.expand_path(__FILE__))
+$LOAD_PATH.unshift dir + '/../lib'
+
+require 'rubygems'
+require 'test/unit'
+begin
+  require 'turn'
+rescue LoadError
+end
+require 'mocha'
+require 'copy'
+
+class Test::Unit::TestCase
+  def self.test(name, &block)
+    define_method("test_#{name.gsub(/\W/,'_')}", &block) if block
+  end
+
+  def self.setup(&block)
+    define_method(:setup, &block)
+  end
+  
+  def self.teardown(&block)
+    define_method(:teardown, &block)
+  end
+end
+
+module CopyAppSetup
+  def app
+    Copy::Server
+  end
+  
+  def setup
+    app.config do
+      set :views, File.dirname(File.expand_path(__FILE__)) + '/test_app/views'
+    end
+  end
+  
+  def setup_auth(user, pass)
+    app.config do
+      set :admin_user, user
+      set :admin_password, pass
+    end
+  end
+  
+  def authorize!
+    setup_auth 'super', 'secret'
+    authorize  'super', 'secret'
+  end
+end