landable 1.7.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2bab73bf093b17b370337984023eac8234b4d072
+  data.tar.gz: e4587f1dcf343bff05b4bc6280913d5d04e9dfa0
+SHA512:
+  metadata.gz: 8569f8fd1867cffe6883e116200aa4060723abd163ff3e29711738c089ba88267e97d5f5ba0ce5305299fc922b5cc0a72db3a9b06ffa46b0c972f352db8ca921
+  data.tar.gz: 4aad2b150a7b185ef673b2ea0f37daa115e57ab944b97cc307fbe92b650fc9c796f40722ba545146e2063c0eb150b563d3058af0d2448903954ad8ab0fb50633

data/.gitignore

@@ -0,0 +1,13 @@
+.DS_Store
+*.swp
+Gemfile.lock
+.bundle/
+log/*.log
+pkg/
+spec/dummy/db/*.sqlite3
+spec/dummy/db/*.sqlite3-journal
+spec/dummy/log/*.log
+spec/dummy/tmp/
+spec/dummy/.sass-cache
+coverage/
+tmp/

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+See README.md before updating this file.
+
+## Unreleased [#]

data/Gemfile

@@ -0,0 +1,15 @@
+source "http://gems.enova.com"
+source "https://rubygems.org"
+
+# Declare your gem's dependencies in landable.gemspec.
+# Bundler will treat runtime dependencies like base dependencies, and
+# development dependencies will be added by default to the :development group.
+gemspec
+
+# Declare any dependencies that are still in development here instead of in
+# your gemspec. These might include edge Rails or gems from your path or
+# Git. Remember to move these dependencies to your gemspec before releasing
+# your gem to rubygems.org.
+
+# To use debugger
+# gem 'debugger'

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2013 Enova International
+
+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,56 @@
+# Landable
+
+Landable is an API for building your CMS. It's implemented as a [Rails Engine](http://guides.rubyonrails.org/engines.html). We like to use Landable with [Publicist](https://github.com/enova/publicist), a great UI for managing content.
+
+
+## Installation
+
+Landable requires [Postgres](https://github.com/ged/ruby-pg). Make sure you have Postgres installed and configured in your app.
+
+Add `gem 'landable'` to your project's Gemfile and run `bundle`.
+
+Run `bundle exec rails g landable:install`, and update the new landable initializer to taste.
+
+Open your routes file, and ensure that the engine is mounted properly. Typically, this will be your final, catch-all route:
+
+```ruby
+My::Application.routes.draw do
+  mount Landable::Engine => '/'
+end
+```
+Install Landable's migrations:
+
+```sh
+rake landable:install:migrations
+rake db:migrate
+```
+
+Checkout the wiki for steps on [configuration](https://github.com/enova/landable/wiki/Configuration).
+
+## Visit Tracking
+Landable includes the ability to track visits.
+
+```ruby
+Landable.configure do |config|
+  # To enable tracking, put one of the following in your Landable initializer:
+  config.traffic_enabled = true  # Enables tracking for all requests.  (:all is also accepted here.)
+  config.traffic_enabled = :html # Enables tracking for only HTML requests.
+end
+```
+
+## Development
+
+Run `./bin/redb` to refresh the dummy app's database.
+
+Run the test suite with `rake landable`.
+
+## Contributing 
+Contributions are welcome - submit a pull request.
+
+* Do include specs to back up all code changes.
+* Do add your changes to the "unreleased" section of [CHANGELOG.md](CHANGELOG.md) (adding this section if it does not exist). Include the pull request number.
+* Don't bump Landable's version number.
+
+## License
+
+Landable is released under the [MIT License](https://github.com/enova/landable/blob/master/MIT-LICENSE).

data/Rakefile

@@ -0,0 +1,22 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+require "bundler_geminabox/gem_tasks"
+Bundler::GemHelper.install_tasks
+
+Dir.glob(File.expand_path('../lib/tasks/landable/*.rake', __FILE__)).each { |f| load f }
+
+desc 'Landable test suite'
+task :landable => [
+  'app:db:test:prepare',
+  'landable:seed',
+  'landable:spec',
+  'landable:cucumber',
+  'landable:pgtap'
+]

data/app/controllers/concerns/landable/variables_concern.rb

@@ -0,0 +1,38 @@
+require 'active_support/concern'
+
+module Landable
+  module VariablesConcern
+    # includes
+    extend ActiveSupport::Concern
+    
+    included do
+      # attribute definitions
+      cattr_accessor :imported_variables do
+        {}
+      end
+    end
+    
+    # standard methods
+    
+    # custom methods
+    module ClassMethods
+      def register_landable_variable(variable_name, method_name = nil)
+        method_name ||= variable_name
+        
+        imported_variables[variable_name] = method_name
+      end
+    end
+    
+    def fetch_landable_variables
+      variables = {}
+      
+      imported_variables.each do |variable_name, method_name| 
+        variables[variable_name] = send(method_name)
+      end
+
+      variables.with_indifferent_access
+    end
+    
+    # end
+  end
+end

data/app/controllers/landable/api/access_tokens_controller.rb

@@ -0,0 +1,48 @@
+require_dependency "landable/api_controller"
+
+module Landable
+  module Api
+    class AccessTokensController < ApiController
+      skip_before_filter :require_author!, only: [:create]
+
+      def show
+        respond_with find_own_access_token
+      end
+
+      def create
+        ident  = AuthenticationService.call(asset_token_params[:username], asset_token_params[:password])
+        author = RegistrationService.call(ident)
+
+        respond_with AccessToken.create!(author: author), status: :created
+      rescue Landable::AuthenticationFailedError
+        head :unauthorized
+      end
+
+      def update
+        token = find_own_access_token
+        token.refresh!
+
+        respond_with token
+      end
+
+      def destroy
+        token = find_own_access_token
+        token.destroy!
+        head :no_content
+      rescue ActiveRecord::RecordNotFound
+        head :unauthorized
+      end
+
+
+      private
+
+      def find_own_access_token(id = params[:id])
+        current_author.access_tokens.fresh.find(id)
+      end
+
+      def asset_token_params
+        params.require(:access_token).permit(:username, :password)
+      end
+    end
+  end
+end

data/app/controllers/landable/api/assets_controller.rb

@@ -0,0 +1,55 @@
+require_dependency "landable/api_controller"
+require_dependency "landable/asset_search_engine"
+
+module Landable
+  module Api
+    class AssetsController < ApiController
+      def index
+        search = Landable::AssetSearchEngine.new search_params.merge(ids: params[:ids])
+        respond_with search.results, meta: search.meta
+      end
+
+      def show
+        respond_with Asset.find(params[:id])
+      end
+
+      def create
+        asset = Asset.new asset_params
+
+        if original = asset.duplicate_of
+          head :moved_permanently, location: asset_url(original)
+          return
+        end
+
+        Asset.transaction do
+          asset.author = current_author
+          asset.save!
+        end
+
+        respond_with asset, status: :created, location: asset_url(asset)
+      end
+
+      def update
+        asset = Asset.find(params[:id])
+
+        asset.update_attributes! asset_params
+
+        respond_with asset
+      end
+
+      private
+
+      def search_params
+        @search_params ||=
+          begin
+            hash = params.permit(search: [:name])
+            hash[:search] || {}
+          end
+      end
+
+      def asset_params
+        params.require(:asset).permit(:id, :name, :description, :data, :file)
+      end
+    end
+  end
+end

data/app/controllers/landable/api/categories_controller.rb

@@ -0,0 +1,13 @@
+module Landable
+  module Api
+    class CategoriesController < ApiController
+      def index
+        respond_with Category.all
+      end
+
+      def show
+        respond_with Category.find(params[:id])
+      end
+    end
+  end
+end

data/app/controllers/landable/api/directories_controller.rb

@@ -0,0 +1,19 @@
+require_dependency "landable/api_controller"
+
+module Landable
+  module Api
+    class DirectoriesController < ApiController
+      def index
+        ids = params[:ids] if params[:ids].present? and params[:ids].is_a? Array
+        ids ||= ['/']
+
+        listings = ids.map { |id| Directory.listing id }
+        respond_with listings
+      end
+
+      def show
+        respond_with Directory.listing(params[:id])
+      end
+    end
+  end
+end

data/app/controllers/landable/api/page_revisions_controller.rb

@@ -0,0 +1,38 @@
+require_dependency "landable/api_controller"
+
+module Landable
+  module Api
+    class PageRevisionsController < ApiController
+      skip_before_filter :require_author!, if: proc { |c|
+        c.action_name == 'show' && c.request.format == :html
+      }
+
+      def index
+        page = Page.find(params[:page_id])
+        respond_with page.revisions.order(:ordinal).reverse
+      end
+
+      def show
+        revision = PageRevision.find(params[:id])
+
+        respond_to do |format|
+          format.json { respond_with revision }
+          format.html { respond_with revision.snapshot, responder: Landable::PageRenderResponder }
+        end
+      end
+
+      def revert_to
+        revision = PageRevision.find(params[:id])
+        revision.page.revert_to! revision
+        respond_with revision
+      end
+
+      def screenshots
+        Landable::ScreenshotService.call PageRevision.find(params[:id])
+
+        # "{}" is valid json, which jquery will accept as a successful response. "" is not.
+        render json: {}, status: 202
+      end
+    end
+  end
+end

data/app/controllers/landable/api/pages_controller.rb

@@ -0,0 +1,96 @@
+require_dependency "landable/api_controller"
+
+module Landable
+  module Api
+    class PagesController < ApiController
+      def index
+        search = Landable::PageSearchEngine.new search_params.merge(ids: params[:ids]), limit: 100
+        respond_with search.results, meta: search.meta
+      end
+
+      def create
+        page = Page.new page_params
+        page.updated_by_author = current_author
+        page.save!
+        respond_with page, status: :created, location: page_url(page)
+      end
+
+      def show
+        respond_with Page.find(params[:id])
+      end
+
+      def update
+        page = Page.find params[:id]
+        page.updated_by_author = current_author
+        page.update_attributes! page_params
+        respond_with page
+      end
+
+      def publish
+        page = Page.find params[:id]
+        page.publish! author_id: current_author.id, notes: params[:notes], is_minor: !!params[:is_minor]
+        respond_with page
+      end
+
+      def preview
+        page  = Page.where(page_id: page_params[:id]).first_or_initialize
+        page.attributes = page_params
+
+        # run the validators and render
+        if page.valid?
+          if layout = page.theme.try(:file) || false
+            content = with_format(:html) do
+              render_to_string text: RenderService.call(page), layout: layout
+            end
+          else
+            content = RenderService.call(page, preview: true)
+          end
+        end
+
+        respond_to do |format|
+          format.json do
+            render json: {
+              page: {
+                preview: content,
+                errors: page.errors,
+              }
+            }
+          end
+        end
+      end
+
+      def screenshots
+        Landable::ScreenshotService.call Page.find(params[:id])
+
+        # "{}" is valid json, which jquery will accept as a successful response. "" is not.
+        render json: {}, status: 202
+      end
+
+      private
+
+      def search_params
+        @search_params ||=
+          begin
+            hash = params.permit(search: [:path])
+            hash[:search] || {}
+          end
+      end
+
+      def page_params
+        params.require(:page).permit(:id, :path, :theme_id, :category_id, :title, :head_content, :body, :status_code, :redirect_url, :lock_version, :abstract, :hero_asset_name,
+                                     meta_tags: [:description, :keywords, :robots])
+      end
+
+      def with_format(format, &block)
+        old_formats = formats
+
+        begin
+          self.formats = [format]
+          return block.call
+        ensure
+          self.formats = old_formats
+        end
+      end
+    end
+  end
+end