kiosk 0.0.1

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2012 Daniel Duvall
+
+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.rdoc

@@ -0,0 +1,25 @@
+= Kiosk
+
+Kiosk provides APIs for integrating WordPress content into a Ruby
+application: a base REST model for retrieving content, a caching layer,
+and a rewriting engine for canonicalizing and contextualizing content
+elements.
+
+This gem was initially developed by the {Office of Letters and
+Light}[http://lettersandlight.org] for use with {National Novel Writing
+Month}[http://nanowrimo.org]. It has since been released under the MIT
+license.
+
+== Basic Usage Patterns
+
+(Documentation is forthcoming.)
+
+== Configuration
+
+(Documentation is forthcoming.)
+
+== Roadmap
+
+In its current state, Kiosk depends on Rails for caching and ActiveResource as
+a base REST implementation. These dependencies will be made optional in the
+near future and alternative implementations made possible.

data/Rakefile

@@ -0,0 +1,26 @@
+# encoding: UTF-8
+require 'rubygems'
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rake'
+
+require 'rspec/core/rake_task'
+require 'rdoc/task'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = './spec/**/*_spec.rb'
+end
+
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Kiosk'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+task :default => :spec

data/lib/kiosk.rb

@@ -0,0 +1,58 @@
+require 'yaml'
+
+# Kiosk provides APIs for integrating WordPress content into a Ruby
+# application: a base REST model for retrieving content, a caching layer, and
+# a rewriting engine for canonicalizing and contextualizing content elements.
+#
+module Kiosk
+  autoload :BadConfig, 'kiosk/bad_config'
+  autoload :ResourceError, 'kiosk/resource_error'
+  autoload :ResourceNotFound, 'kiosk/resource_not_found'
+
+  autoload :Cacheable, 'kiosk/cacheable'
+  autoload :Cdn, 'kiosk/cdn'
+  autoload :Claim, 'kiosk/claim'
+  autoload :ClaimedNode, 'kiosk/claimed_node'
+  autoload :Controller, 'kiosk/controller'
+  autoload :Document, 'kiosk/document'
+  autoload :Indexer, 'kiosk/indexer'
+  autoload :Localizable, 'kiosk/localizable'
+  autoload :Origin, 'kiosk/origin'
+  autoload :ProspectiveNode, 'kiosk/prospective_node'
+  autoload :Prospector, 'kiosk/prospector'
+  autoload :Resource, 'kiosk/resource'
+  autoload :ResourceURI, 'kiosk/resource_uri'
+  autoload :Rewrite, 'kiosk/rewrite'
+  autoload :Rewriter, 'kiosk/rewriter'
+  autoload :Searchable, 'kiosk/searchable'
+
+  ##############################################################################
+  # Module methods
+  ##############################################################################
+  class << self
+    # Returns the parsed `config/kiosk.yml`.
+    #
+    def config
+      @config ||= YAML.load(File.open("#{Rails.root}/config/kiosk.yml"))
+    end
+
+    # Returns the configuration for the current environment's content origin.
+    #
+    def origin(env = Rails.env)
+      @origins ||= {}
+
+      unless config['origins'] && (config['origins'][env] || config['origins']['default'])
+        raise BadConfig, "no origin configured for the `#{env}' or default environment"
+      end
+
+      @origins[env] ||= Origin.new(config['origins'][env] || config['origins']['default'])
+    end
+
+    # Rewriter object responsible for rewriting resource content.
+    #
+    def rewriter
+      @rewriter ||= Rewriter.new
+    end
+  end
+
+end

data/lib/kiosk/bad_config.rb

@@ -0,0 +1,5 @@
+require 'active_resource'
+require 'active_resource/exceptions'
+
+class Kiosk::BadConfig < StandardError #:nodoc:
+end

data/lib/kiosk/cacheable.rb

@@ -0,0 +1,6 @@
+module Kiosk
+  module Cacheable
+    autoload :Resource, 'kiosk/cacheable/resource'
+    autoload :Connection, 'kiosk/cacheable/connection'
+  end
+end

data/lib/kiosk/cacheable/connection.rb

@@ -0,0 +1,102 @@
+module Kiosk
+  module Cacheable::Connection
+    # Sets a value or block used to determine the expiry of written cache
+    # entries. If a block is given, its first argument will be the object that
+    # is about to be written.
+    #
+    def cache_expiry=(expiry)
+      @cache_expiry = expiry.is_a?(Proc) ? expiry : Proc.new { |r| expiry }
+    end
+
+    # Returns the expiry in seconds for the given resource.
+    #
+    def cache_expiry_of(resource)
+      @cache_expiry && @cache_expiry.call(resource)
+    end
+
+    def cache_expire_by_path(path)
+      cache(:delete, cache_key(path))
+    end
+
+    def cache_expire_by_pattern(pattern)
+      key_base = cache_key("")
+      key = pattern.is_a?(Regexp) ? /^#{key_base}#{pattern}/ : "#{key_base}#{pattern}"
+      cache(:delete_matched, key)
+    end
+
+    # Returns the type of key matcher supported by the cache store. Note that
+    # the type returned here may not be accurate for cache stores that don't
+    # support matchers at all. For those cases, you should still expect
+    # NotImplemented exceptions to be thrown when calling
+    # +cache_expire_by_pattern+.
+    #
+    def cache_key_matcher
+      case Rails.cache
+      when ActiveSupport::Cache::RedisStore
+        :glob
+      else
+        :regexp
+      end
+    end
+
+    def get(*arguments) #:nodoc:
+      cache_read_write(arguments.first) { super }
+    end
+
+    def delete(*arguments) #:nodoc:
+      cache_expire(arguments.first) { super }
+    end
+
+    def put(*arguments) #:nodoc:
+      cache_expire(arguments.first) { super }
+    end
+
+    def post(*arguments) #:nodoc:
+      cache_expire(arguments.first) { super }
+    end
+
+    def head(*arguments) #:nodoc:
+      cache_read_write(arguments.first) { super }
+    end
+
+    private
+
+    # Proxy for the Rails cache store.
+    #
+    def cache(operation, *arguments)
+      Rails.cache.send(operation, *arguments) if Rails.cache
+    end
+
+    # Wraps the given block in a cache read/write pattern. If a cached entry
+    # is not found using the given key then the result of the yielded block is
+    # written to the cache using the same key. Either a previously cached or
+    # fresh result is returned.
+    #
+    def cache_read_write(key)
+      if result = cache(:read, cache_key(key))
+        result = JSON.parse(result)
+      elsif result = yield
+        options = (expiry = cache_expiry_of(result)) ? {:expires_in => expiry} : {}
+        cache(:write, cache_key(key), result.to_json, options) if result
+      end
+      result
+    end
+
+    # Wraps the given block in a cache deletion. The cache entry identified by
+    # the given key is deleted after the block is yielded. If any uncaught
+    # exception occurs during the yield, the entry will not be deleted.
+    #
+    def cache_expire(key)
+      result = yield
+      cache(:delete, cache_key(key))
+      result
+    end
+
+    # Constructs a fully qualified URL from the given path, to be used as a
+    # cache key.
+    #
+    def cache_key(path)
+      "#{site.scheme}://#{site.host}:#{site.port}#{path}"
+    end
+  end
+end

data/lib/kiosk/cacheable/resource.rb

@@ -0,0 +1,90 @@
+require 'active_support/concern'
+
+module Kiosk
+  module Cacheable::Resource
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Specifies the length of time for which a resource should stay cached.
+      # Either a +Fixnum+ (time in seconds) or block can be given. The block
+      # should accept the resource as its argument and should return the
+      # expiry time for the resource in seconds.
+      #
+      # Keep in mind that the underlying cache store may not support
+      # expiration length. In that case, this option has no effect.
+      #
+      def cached_expire_in(expiry = nil, &blk)
+        connection.cache_expiry = expiry || blk
+      end
+
+      # Reimplements method to provide a cacheable connection.
+      #
+      def connection(*args)
+        connection = super(*args)
+        connection.extend(Cacheable::Connection) unless connection.is_a?(Cacheable::Connection)
+        connection
+      end
+
+      # Expire from the cache the resource identified by the given id.
+      #
+      def expire(id)
+        connection.cache_expire_by_path(element_path(id))
+      end
+
+      # Expire from the cache the resource identified by the given slug.
+      #
+      def expire_by_slug(slug)
+        connection.cache_expire_by_path(element_path_by_slug(slug))
+      end
+
+      # Expire from the cache the resource identified by both the slug and id.
+      # Notify any observers of expiration.
+      #
+      def expire_resource(resource)
+        notify_observers(:before_expire, resource)
+
+        expire(resource.id)
+        expire_by_slug(resource.slug)
+
+        if @connection_keys_to_expire
+          begin
+            @connection_keys_to_expire.each { |key| connection.cache_expire_by_pattern(key) }
+          rescue NotImplementedError
+          end
+        end
+
+        notify_observers(:after_expire, resource)
+      end
+
+      # When a resource is explicitly expired from the cache, cache entries
+      # matching URLs to the given API method are deleted as well.
+      #
+      def expires_connection_methods(*methods)
+        matchers = methods.map do |method|
+          case connection.cache_key_matcher
+          when :glob
+            "#{api_path_to(method)}*"
+          when :regexp
+            /^#{Regexp.escape(api_path_to(method))}/
+          end
+        end
+
+        expires_connection_keys(*matchers)
+      end
+
+      private
+
+      def expires_connection_keys(*keys)
+        (@connection_keys_to_expire ||= []).concat(keys)
+      end
+    end
+
+    module InstanceMethods
+      # Expire the resource from the cache.
+      #
+      def expire
+        self.class.expire_resource(self)
+      end
+    end
+  end
+end

data/lib/kiosk/cdn.rb

@@ -0,0 +1,28 @@
+module Kiosk
+  class Cdn
+    attr_reader :host
+
+    def initialize(config = {})
+      @host = config['host']
+    end
+
+    def configured?
+      @host
+    end
+
+    def rewrite_node(node)
+      if configured?
+        node.uri_attribute.content = rewrite_uri(URI.parse(node.uri_attribute.content)).to_s
+      end
+    rescue URI::InvalidURIError
+      nil
+    end
+
+    def rewrite_uri(uri)
+      if configured?
+        uri.host = host
+      end
+      uri
+    end
+  end
+end

data/lib/kiosk/claim.rb

@@ -0,0 +1,12 @@
+module Kiosk
+  module Claim
+    autoload :NodeClaim, 'kiosk/claim/node_claim'
+    autoload :PathClaim, 'kiosk/claim/path_claim'
+
+    class << self
+      def new(type = :node, *args, &blk)
+        "kiosk/claim/#{type}_claim".classify.constantize.new(*args, &blk)
+      end
+    end
+  end
+end

data/lib/kiosk/claim/node_claim.rb

@@ -0,0 +1,44 @@
+module Kiosk
+  module Claim
+    class NodeClaim
+      attr_reader :model, :selector, :parser
+
+      def initialize(model, options = {}, &parser)
+        raise ArgumentError.new('no selector given') unless options[:selector]
+        raise ArgumentError.new('no block provided') unless block_given?
+
+        @model = model
+        @selector = options[:selector]
+        @parser = parser
+      end
+
+      # Stakes the claim over the given content document and yields the provided
+      # block for each match. The block is passed each node, which has been
+      # extended with implementation in +ClaimedNode+.
+      #
+      def stake!(document)
+        select_from(document).each do |node|
+          unless node.is_a?(ClaimedNode)
+            node.extend(ProspectiveNode) unless node.is_a?(ProspectiveNode)
+
+            # If the parser finds anything in the selected node, stake the claim
+            if attributes = parser.call(node)
+              node.extend(ClaimedNode)
+              node.resource = @model.new(attributes)
+
+              yield node if block_given?
+            end
+          end
+        end
+      end
+
+      protected
+
+      # Implements the selection of nodes to process when staking the claim.
+      #
+      def select_from(document)
+        document.css(selector)
+      end
+    end
+  end
+end

data/lib/kiosk/claim/path_claim.rb

@@ -0,0 +1,11 @@
+module Kiosk
+  module Claim
+    class PathClaim < NodeClaim
+      def initialize(type, options = {}, &parser)
+        raise ArgumentError.new('no path pattern given') unless options[:pattern]
+
+        super(type, options) { |node| node.match_uri(options[:pattern], options[:shims]) }
+      end
+    end
+  end
+end