kiosk 0.0.1

data/lib/kiosk/claimed_node.rb

@@ -0,0 +1,9 @@
+module Kiosk
+  module ClaimedNode
+    attr_accessor :resource
+
+    def uri_attribute
+      (name = ['href', 'src'].detect { |attr| attributes.key?(attr) }) && attributes[name]
+    end
+  end
+end

data/lib/kiosk/controller.rb

@@ -0,0 +1,61 @@
+require 'active_support/concern'
+
+module Kiosk
+  # Adds the ability to declare content rewrites in a controller.
+  #
+  module Controller
+    extend ActiveSupport::Concern
+
+    module InstanceMethods
+      # Declares a rewrite of content nodes that sets the host portion of
+      # each node's URI attribute (href or src) to target the configured CDN
+      # host.
+      #
+      def rewrite_cdn_paths_for(resource_model)
+        Kiosk.rewriter.add_rewrite(Rewrite.new(:cdn, resource_model))
+      end
+
+      # Declares a rewrite of content nodes.
+      #
+      # Example:
+      #
+      #   class PostsController
+      #     include Kiosk::Controller
+      #
+      #     before_filter do
+      #       rewrite_content_for(Attachment) do |attachment,node|
+      #         case node.name
+      #         when 'a'
+      #           node['title'] = 'Some photo'
+      #         when 'img'
+      #           node['src'] = attachment_path(attachment.filename)
+      #         end
+      #       end
+      #     end
+      #   end
+      #
+      def rewrite_content_for(resource_model, &blk)
+        Kiosk.rewriter.add_rewrite(Rewrite.new(:node, resource_model, &blk))
+      end
+
+      # Declares a rewrite of content nodes that sets a new URL any href or src
+      # attributes (the first one found, it that order). The given block is
+      # passed the instantiated resource and node as its arguments and should
+      # return the new value for the node attribute.
+      #
+      # Example:
+      #
+      #   class PostsController
+      #     include Kiosk::Controller
+      #
+      #     before_filter do
+      #       rewrite_paths_for(Post) { |post| post_path(post.slug) }
+      #     end
+      #   end
+      #
+      def rewrite_paths_for(resource_model, &blk)
+        Kiosk.rewriter.add_rewrite(Rewrite.new(:path, resource_model, &blk))
+      end
+    end
+  end
+end

data/lib/kiosk/document.rb

@@ -0,0 +1,6 @@
+require 'nokogiri'
+
+module Kiosk
+  class Document < Nokogiri::HTML::DocumentFragment
+  end
+end

data/lib/kiosk/indexer.rb

@@ -0,0 +1,5 @@
+module Kiosk
+  module Indexer
+    autoload :Adapter, 'kiosk/indexer/adapter'
+  end
+end

data/lib/kiosk/indexer/adapter.rb

@@ -0,0 +1,14 @@
+module Kiosk
+  module Indexer
+    module Adapter
+      autoload :Base, 'kiosk/indexer/adapter/base'
+      autoload :ThinkingSphinxAdapter, 'kiosk/indexer/adapter/thinking_sphinx_adapter'
+
+      class << self
+        def new(type = :thinking_sphinx, *args)
+          "kiosk/indexer/adapter/#{type}_adapter".classify.constantize.new(*args)
+        end
+      end
+    end
+  end
+end

data/lib/kiosk/indexer/adapter/base.rb

@@ -0,0 +1,10 @@
+module Kiosk::Indexer::Adapter
+  class Base
+    def extend_model(model)
+      model.class_exec(self.class.const_get(:Resource)) { |mixin| include mixin }
+    end
+
+    def index(name)
+    end
+  end
+end

data/lib/kiosk/indexer/adapter/thinking_sphinx_adapter.rb

@@ -0,0 +1,266 @@
+require 'active_support/concern'
+
+module Kiosk::Indexer::Adapter
+  class ThinkingSphinxAdapter < Base
+
+    def index(name, io = STDOUT)
+      index = nil
+
+      ThinkingSphinx.context.indexed_resources.each do |res|
+        if i = res.constantize.sphinx_indexes.detect { |index| index.name == name }
+          index = i
+        end
+      end
+
+      index.write_xml_to(io) if index
+    end
+
+    module Resource
+      extend ActiveSupport::Concern
+
+      included do
+        # Mixin implementation for Thinking Sphinx
+        unless ThinkingSphinx.context.is_a?(Context)
+          ThinkingSphinx.context.extend(Context)
+        end
+
+        unless ThinkingSphinx::Configuration.instance.configuration.is_a?(Configuration)
+          ThinkingSphinx::Configuration.instance.configuration.extend(Configuration)
+        end
+      end
+
+      module ClassMethods
+        attr_accessor :sphinx_indexes
+
+        def define_index(name, &blk)
+          self.sphinx_indexes ||= []
+
+          ThinkingSphinx.context.add_indexed_resource self
+
+          index = Index.new(self, name.to_s)
+          index.instance_exec(&blk)
+
+          sphinx_indexes << index unless sphinx_indexes.any? { |i| i.name == index.name }
+        end
+
+        def search(*args)
+          options = args.extract_options!
+          query = args.first
+
+          Search.new(query, options).execute_for(self)
+        end
+
+        def sphinx_index_names
+          sphinx_indexes.collect { |index| index.name }
+        end
+
+        def to_riddle
+          if sphinx_indexes
+            sphinx_indexes.collect { |index| index.to_riddle }.flatten
+          else
+            []
+          end
+        end
+      end
+    end
+
+    class Search
+      attr_reader :query, :options
+
+      def initialize(query, options = {})
+        @query = query
+        @options = {:comment => ''}.merge(options)
+        @proxy = SearchProxy.new(@options)
+      end
+
+      def execute_for(model)
+        query = @proxy.star_query(@query)
+        using_options(@options) do
+          SearchResults.new(client.query(query, index_names_for(model), @options[:comment]), model, @options)
+        end
+      end
+
+      private
+
+      def using_options(options)
+        original_options = {}
+
+        options.each do |name,value|
+          if client.respond_to?("#{name}=")
+            original_options[name] = value
+            client.send("#{name}=", value)
+          end
+        end
+
+        result = yield
+
+        original_options.each do |name,value|
+          client.send("#{name}=", value)
+        end
+
+        result
+      end
+
+      def index_names_for(model)
+        model.sphinx_index_names.join(',')
+      end
+
+      def client
+        ThinkingSphinx::Configuration.instance.client
+      end
+    end
+
+    # Used to steal methods from +ThinkingSphinx::Search+.
+    #
+    class SearchProxy < ThinkingSphinx::Search
+      def initialize(options = {})
+        @options = options
+      end
+
+      def star_query(query)
+        @options[:star] ? super(query) : query
+      end
+    end
+
+    class SearchResults < Array
+      attr_reader :results
+
+      def initialize(sphinx_results, model, search_options)
+        @model = model
+        @results = sphinx_results
+        @options = search_options
+
+        populate if @results && @results[:matches]
+      end
+
+      def current_page
+        @options[:page].blank? ? 1 : @options[:page].to_i
+      end
+
+      def per_page
+        (@options[:per_page] || 20).to_i
+      end
+
+      def total_entries
+        @results[:total_found] || 0
+      end
+
+      def total_pages
+        (@results[:total] / per_page.to_f).ceil
+      end
+
+      private
+
+      def populate
+        replace(@results[:matches].collect { |match|
+          begin
+            @model.find(match[:doc])
+          rescue Kiosk::ResourceNotFound => e
+            @model.new
+          end
+        })
+      end
+    end
+
+    module Context
+      attr_reader :indexed_resources
+
+      def add_indexed_resource(resource)
+        resource = resource.name if resource.is_a?(Class)
+
+        @indexed_resources ||= []
+        @indexed_resources << resource unless @indexed_resources.include?(resource)
+      end
+    end
+
+    module Configuration
+      # Reimplement +Riddle::Configuration#render+ to include our own indexes
+      # in the config before it's rendered.
+      #
+      def render
+        ThinkingSphinx.context.indexed_resources.each do |resource|
+          resource.constantize.to_riddle.each do |index|
+            indices << index unless indices.any? { |i| i.name == index.name }
+          end
+        end
+
+        super
+      end
+    end
+
+    class Index
+      attr_reader :mode, :name
+
+      def initialize(model, name)
+        @model = model
+        @name = name
+
+        @fields = []
+      end
+
+      def indexes(*fields)
+        @fields += fields.collect { |field| Field.new(field) }
+      end
+
+      def config
+        @config ||= ThinkingSphinx::Configuration.instance
+      end
+
+      def to_riddle
+        index = Riddle::Configuration::Index.new(@name)
+        index.path = File.join(config.searchd_file_path, index.name)
+
+        config.index_options.each do |key,value|
+          method = "#{key}=".to_sym
+          index.send(method, value) if index.respond_to?(method)
+        end
+
+        source = Riddle::Configuration::XMLSource.new("#{@name}_source", :xmlpipe2)
+        source.xmlpipe_command = rake("kiosk:index[#{name}]")
+
+        index.sources << source
+
+        [index]
+      end
+
+      def write_xml_to(io)
+        xm = Builder::XmlMarkup.new(:target => io)
+
+        xm.instruct!
+        xm.sphinx :docset, 'xmlns:sphinx' => 'http://sphinxsearch.com' do
+          xm.sphinx :schema do
+            @fields.each { |field| field.to_xml(xm) }
+          end
+
+          @model.all.each do |resource|
+            xm.sphinx :document, :id => resource.id do
+              @fields.each do |field|
+                xm.send(field.name, resource.send(field.name))
+              end
+            end
+          end
+        end
+      end
+
+      private
+
+      def rake(task)
+        "#{Gem.bin_path('rake', 'rake')} --silent -f #{Rails.root}/Rakefile #{task}"
+      end
+    end
+
+    class Field
+      attr_reader :name
+
+      def initialize(name)
+        name = name.to_s
+        raise ArgumentError.new('invalid name') unless name =~ /^\w+$/
+        @name = name
+      end
+
+      def to_xml(builder)
+        builder.sphinx :field, :name => name
+      end
+    end
+  end
+end

data/lib/kiosk/localizable.rb

@@ -0,0 +1,5 @@
+module Kiosk
+  module Localizable
+    autoload :Resource, 'kiosk/localizable/resource'
+  end
+end

data/lib/kiosk/localizable/resource.rb

@@ -0,0 +1,30 @@
+require 'active_support/concern'
+
+module Kiosk
+  # Provides integration between I18n and WordPress for automatic retrieval of
+  # content translated to the language of the user session. This module
+  # depends on the installation of the WPML-JSON-API WordPress plugin.
+  #
+  module Localizable::Resource
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      attr_accessor :locale_scope_stack
+
+      # Executes the given block within a scope that limits found content
+      # resources to the given locale.
+      #
+      def with_locale(locale, &blk)
+        with_parameters(:language => locale, &blk)
+      end
+
+      # Executes the given block within a scope that translates found content
+      # resources to the given locale. See +Resource.with_params+ for details
+      # on scope execution and inheritance.
+      #
+      def localized_to(locale, &blk)
+        with_parameters(:to_language => locale, &blk)
+      end
+    end
+  end
+end

data/lib/kiosk/localizer.rb

@@ -0,0 +1,17 @@
+require 'i18n'
+
+module Kiosk
+  # Provides an +ActionController+ filter that scopes all content resource
+  # calls to only fetch content for the default locale and localize it all to
+  # the current request locale.
+  #
+  module Localizer
+    def self.around(controller)
+      Resource.with_locale(Kiosk.origin.default_locale || I18n.default_locale) do
+        Resource.localized_to(I18n.locale) do
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/kiosk/origin.rb

@@ -0,0 +1,20 @@
+module Kiosk
+  class Origin
+    attr_reader :site, :indexer, :default_locale, :cdn
+
+    def initialize(config)
+      @site = (config['site'] || '').sub(/\/+$/, '') + '/'
+      @indexer = Kiosk::Indexer::Adapter.new(config['indexer']) if config['indexer']
+      @default_locale = config['default_locale']
+      @cdn = Kiosk::Cdn.new(config['cdn'] || {})
+    end
+
+    def searcher
+      @indexer
+    end
+
+    def site_uri
+      URI.parse(site)
+    end
+  end
+end