landable 1.7.0

data/lib/landable/core_ext/ipaddr.rb

@@ -0,0 +1,18 @@
+require 'ipaddr'
+
+module Landable
+  module CoreExt
+    module IPAddr
+      def ==(other)
+        case other
+        when true, false then false
+        else super
+        end
+      end
+    end
+  end
+end
+
+class IPAddr
+  include Landable::CoreExt::IPAddr
+end

data/lib/landable/engine.rb

@@ -0,0 +1,69 @@
+require "rack/cors"
+require "active_model_serializers"
+require "carrierwave"
+require "rake"
+
+module Landable
+  class Engine < ::Rails::Engine
+    isolate_namespace Landable
+
+    config.generators do |g|
+      g.test_framework :rspec
+      g.fixture_replacement :factory_girl, :dir => 'spec/factories'
+    end
+
+    initializer "landable.enable_cors" do |app|
+      config = Landable.configuration
+      if config.cors.enabled?
+        app.middleware.insert 0, Rack::Cors do
+          allow do
+            origins config.cors.origins
+            resource "#{config.api_namespace}/*",
+              methods: [:get, :post, :put, :patch, :delete],
+              headers: :any,
+              expose: 'X-Landable-Media-Type',
+              credentials: false,
+              max_age: 15.minutes
+          end
+        end
+      end
+    end
+
+    initializer "landable.json_schema" do |app|
+      if ENV['LANDABLE_VALIDATE_JSON']
+        require 'rack/schema'
+        app.middleware.use Rack::Schema
+      end
+    end
+
+    initializer "landable.seed_required" do |app|
+      Landable::Seeds.seed(:required) rescue nil
+    end
+
+    initializer "landable.create_themes" do |app|
+      Theme.create_from_layouts! rescue nil
+    end
+
+    initializer 'landable.create_templates' do |app|
+      Template.create_from_partials! rescue nil
+    end
+
+    initializer "landable.action_controller" do
+      ActiveSupport.on_load :action_controller do
+        # includes
+        include Landable::Traffic
+        include Landable::VariablesConcern
+
+        # helpers
+        helper Landable::PagesHelper
+
+        # tracking
+        if Landable.configuration.traffic_enabled
+          prepend_around_action :track_with_landable!
+        end
+
+        # end
+      end
+    end
+  end
+end

data/lib/landable/error.rb

@@ -0,0 +1,16 @@
+module Landable
+  class Error < StandardError
+
+    STATUS_CODE = 500
+
+    def initialize message = nil
+      message ||= "Status code: #{status_code} (Hint: rescue this in your ApplicationController)"
+      super
+    end
+
+    def status_code
+      self.class::STATUS_CODE
+    end
+
+  end
+end

data/lib/landable/inflections.rb

@@ -0,0 +1,4 @@
+# TODO: require activesupport/...
+ActiveSupport::Inflector.inflections do |inflect|
+  inflect.irregular 'medium', 'mediums'
+end

data/lib/landable/layout.rb

@@ -0,0 +1,60 @@
+# TODO: Custom resolver for db themes: http://blog.jgarciam.net/post/21098440864/database-stored-templates-on-ruby-on-rails
+# TODO: Multiple extentions with tilt
+# TODO: Allow converting db-backed Theme to file-backed Theme
+
+module Landable
+  class Layout
+    def initialize(file)
+      @file = file
+    end
+
+    def process
+      return if @processed
+
+      path = @file.dup
+      self.class.paths.each { |p| path.sub!(p, '') }
+
+      path.sub!(/^\//, '')
+
+      @path, @extension = path.split('.html.', 2)
+
+      @body = File.read(@file)
+
+      @processed = true
+    end
+
+    def to_theme
+      process unless @processed
+
+      theme = Theme.where(file: @path).first_or_initialize
+      theme.name          ||= @path.gsub('/', ' ').titlecase
+      theme.extension       = @extension
+      theme.description     = description if theme.description.blank? || theme.description =~ /^Defined in/
+      theme.body            = @body
+      theme.editable        = false
+      theme.thumbnail_url ||= "http://placehold.it/300x200"
+
+      theme.save!
+
+      theme
+    end
+
+    def description
+      "Defined in #@path.html.#@extension"
+    end
+
+    class << self
+      def all
+        files.map { |file| new(file) }
+      end
+
+      def files
+        paths.map { |path| Dir[path + "/**/[^_]*.html.*"] }.flatten
+      end
+
+      def paths
+        @paths ||= Dir[Rails.root.join('app/views/layouts').to_s]
+      end
+    end
+  end
+end

data/lib/landable/liquid.rb

@@ -0,0 +1,27 @@
+require 'liquid'
+
+require 'landable/liquid/tags'
+require 'landable/liquid/asset_tags'
+require 'landable/liquid/filters'
+require 'landable/liquid/drops'
+
+# Tag generators
+Liquid::Template.register_tag('title_tag',    Landable::Liquid::TitleTag)
+Liquid::Template.register_tag('meta_tags',    Landable::Liquid::MetaTag)
+Liquid::Template.register_tag('head_content', Landable::Liquid::HeadContent)
+Liquid::Template.register_tag('head',         Landable::Liquid::Head)
+Liquid::Template.register_tag('body',         Landable::Liquid::Body)
+
+%w(img_tag image_tag javascript_include_tag stylesheet_link_tag).each do |tag|
+  Liquid::Template.register_tag(tag, Landable::Liquid::AssetTag)
+end
+
+# Only called tags so we can use a function-like syntax
+Liquid::Template.register_tag('asset_url', Landable::Liquid::AssetAttributeTag)
+Liquid::Template.register_tag('asset_description', Landable::Liquid::AssetAttributeTag)
+
+# Template references
+Liquid::Template.register_tag('template', Landable::Liquid::TemplateTag)
+
+# Helpers
+Liquid::Template.register_filter(Landable::Liquid::DefaultFilter)

data/lib/landable/liquid/asset_tags.rb

@@ -0,0 +1,76 @@
+require 'action_view'
+
+module Landable
+  module Liquid
+
+    class AssetTag < ::Liquid::Tag
+      attr_accessor :tag_name, :asset_name
+
+      # we'll be calling up to methods in here
+      include ActionView::Helpers::AssetTagHelper
+
+      # included for asset digest support
+      include Sprockets::Rails::Helper
+
+      def initialize(tag_name, param, tokens)
+        @tag_name = tag_name
+        @asset_name = param.strip
+        @tokens = tokens
+      end
+
+      def render(context)
+        tag_method = tag_name.to_sym
+        tag_method = :image_tag if tag_method == :img_tag
+
+        # if this matches an application asset, use that
+        if assets_environment[asset_name]
+          send tag_method, asset_name
+
+        # otherwise, find an asset of our own
+        else
+          asset = lookup_asset context, asset_name
+
+          options = {}
+          options[:alt] = asset.description if tag_method == :image_tag
+
+          send tag_method, asset.public_url, options
+        end
+      end
+
+      protected
+
+      def lookup_asset(context, name)
+        assets = context.registers.fetch(:assets) do
+          raise ArgumentError.new("`assets' value was never registered with the template")
+        end
+
+        assets.fetch(name) do
+          raise ArgumentError.new("No `#{name}' asset available in #{assets.inspect}")
+        end
+      end
+
+      # stuff for sprockets
+      delegate :assets_prefix, :digest_assets, to: 'ActionView::Base'
+
+      # ActionView::Base.assets_environment will be nil if the pipeline is
+      # disabled - use this instead
+      def assets_environment
+        Rails.application.assets
+      end
+    end
+
+    class AssetAttributeTag < AssetTag
+      def render(context)
+        asset = lookup_asset context, asset_name
+        attribute = tag_name.sub /^asset_/, ''
+
+        if attribute == 'url'
+          asset.public_url
+        else
+          asset.send attribute
+        end
+      end
+    end
+
+  end
+end

data/lib/landable/liquid/drops.rb

@@ -0,0 +1,46 @@
+# Drops are for lazy-loading content.
+#  - http://www.rubydoc.info/github/Shopify/liquid/Liquid/Drop
+#  - https://github.com/Shopify/liquid/blob/master/lib/liquid/drop.rb
+
+module Landable
+  module Liquid
+
+    # CategoryProxy gives us these:
+    #
+    # {{ categories.size }}
+    #
+    # {% for category in categories %}
+    #   {{ category.name }}: {{ category.pages.size }} pages
+    # {% endfor %}
+    #
+    # <h1>Blog posts</h1>
+    # <ul>
+    #   {% for page in categories.blog.pages %}
+    #     <li><a href="{{ page.url }}">{{ page.name }}</a></li>
+    #   {% endfor %}
+    # </ul>
+    class CategoriesDrop < ::Liquid::Drop
+
+      def before_method method_name
+        category_cache[method_name] ||= ::Landable::Category.find_by_slug method_name
+      end
+
+      def size
+        @size ||= Category.count
+      end
+
+      def each &block
+        ::Landable::Category.all.each &block
+      end
+
+
+      protected
+
+      def category_cache
+        @category_cache ||= {}
+      end
+
+    end
+
+  end
+end

data/lib/landable/liquid/filters.rb

@@ -0,0 +1,11 @@
+module Landable
+  module Liquid
+
+    module DefaultFilter
+      def default(input, default_output=nil)
+        input.presence ? input : default_output
+      end
+    end
+
+  end
+end

data/lib/landable/liquid/tags.rb

@@ -0,0 +1,91 @@
+require 'action_view'
+
+module Landable
+  module Liquid
+
+    class Tag < ::Liquid::Tag
+      include ActionView::Helpers::TagHelper
+
+      protected
+      def lookup_page(context)
+        context.registers.fetch(:page) do
+          raise ArgumentError.new("`page' value was never registered with the template")
+        end
+      end
+    end
+
+    class TitleTag < Tag
+      def render(context)
+        page = lookup_page context
+        content_tag(:title, page.title)
+      end
+    end
+
+    class MetaTag < Tag
+      def render(context)
+        page = lookup_page context
+        tags = page.meta_tags || {}
+
+        tags.map { |name, value|
+          tag(:meta, name: name, content: value)
+        }.join("\n")
+      end
+    end
+
+    class HeadContent < Tag
+      def render(context)
+        page = lookup_page context
+
+        page.head_content
+      end
+    end
+
+    class Head < Tag
+      def render(context)
+        page = lookup_page context
+
+        head = []
+
+        ['title_tag', 'meta_tags', 'head_content'].each do |tag_name|
+           tag = eval("Landable::Liquid::#{tag_name.classify}").new(tag_name, nil, nil)
+           head << tag.render(context) if tag.render(context).present?
+         end
+
+        head.join("\n")
+      end
+    end
+
+    class Body < Tag
+      def render(context)
+        context.environments.first.fetch('body')
+      end
+    end
+
+    class TemplateTag < Tag
+      def initialize(tag, param, tokens)
+        param_tokens = param.split(/\s+/)
+        @template_slug = param_tokens.shift
+        @variables = Hash[param_tokens.join(' ').scan(/([\w_]+):\s+"([^"]*)"/)]
+      end
+
+      def render(context)
+        template = Landable::Template.find_by_slug @template_slug
+
+        if template
+          if template.partial?
+            if context.registers[:responder].present? 
+              context.registers[:responder].controller.render_to_string(partial: template.file)
+            else
+              "<!-- render error: unable to render \"#{@template_slug}\", no controller/responder present -->"
+            end
+          else
+            ::Liquid::Template.parse(template.body).render @variables
+          end
+        else
+          "<!-- render error: missing template \"#{@template_slug}\" -->"
+        end
+      end
+    end
+
+  end
+end

data/lib/landable/migration.rb

@@ -0,0 +1,40 @@
+class Landable::Migration < ActiveRecord::Migration
+  class << self
+    def connection_search_path(conn)
+      conn.execute("SHOW SEARCH_PATH")[0]["search_path"]
+    end
+
+    def models
+      @models ||= begin
+        c = Landable.constants.map { |c| "Landable::#{c.to_s}".constantize }
+        c += Landable::Traffic.constants.map { |c| "Landable::Traffic::#{c.to_s}".constantize }
+        c.select { |c| c.kind_of? Class and c.ancestors.include? ActiveRecord::Base }
+      end
+    end
+
+    def clear_cache!
+      models.each &:reset_primary_key
+      ActiveRecord::Base.connection.schema_cache.clear!
+    end
+  end
+
+  def exec_migration(conn, direction)
+    # come what may, keep the connection's schema search path intact
+    with_clean_connection(conn) do
+      super
+    end
+
+    # reset a few things, lest we pollute the way for those who follow
+    self.class.clear_cache!
+  end
+
+
+  protected
+
+  def with_clean_connection(conn)
+    original_search_path = self.class.connection_search_path conn
+    yield
+    conn.schema_search_path = original_search_path
+  end
+
+end