ninetails 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5c7c8740a522a490770f25cf5bac37825ec24a1e
+  data.tar.gz: e4cd25c9dbcd7ae2799745e180a7d3d95b47cc98
+SHA512:
+  metadata.gz: 52af399db0d77ca5b95646da1de1011ad319ab8f23a9957395a24e873009069312c644ad439ba0c99664443cb91c357d67fb563ca73fd0fe4ae3880924df2cfc
+  data.tar.gz: 661dc75c75578353f715d370668c169a46803000328c3f492c8c5aa672166301215e8aa3fa5174169699b75933a06811b79abf6cbc9efb22f47456d5ec82731e

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2015 iZettle AB
+
+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,17 @@
+![Ninetails](http://i.imgur.com/jv28Kg3.png)
+
+[![Build Status](https://travis-ci.org/iZettle/ninetails.svg)](https://travis-ci.org/iZettle/ninetails)
+
+Ninetails is a simple CMS API engine. It is designed on the idea of a CMS which is limited in scope in that not all aspects of a page should be editable. Instead, you can define Sections, Elements, and Properties which are editable and can then be loaded in and styled in a reliable manner. It gives you the control to decide exactly what should and what should not be editable in your project.
+
+## Getting started
+
+Ninetails is a mountable Rails engine, so it needs to be loaded into your app. You app is also where you will define your components which Ninetails should expose. Start by adding it to your Gemfile:
+
+```
+gem "ninetails"
+```
+
+## Thinking in sections
+
+## Setting up Sections, Elements, and Components

data/Rakefile

@@ -0,0 +1,19 @@
+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'
+
+Bundler::GemHelper.install_tasks
+
+Dir[File.join(File.dirname(__FILE__), 'tasks/**/*.rake')].each {|f| load f }
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+desc "Run all specs in spec directory (excluding plugin specs)"
+RSpec::Core::RakeTask.new(:spec => 'app:db:test:prepare')
+task :default => :spec

data/app/components/ninetails/element.rb

@@ -0,0 +1,55 @@
+module Ninetails
+  class Element
+    include Ninetails::PropertyStore
+
+    def reference
+      @reference ||= SecureRandom.uuid
+    end
+
+    def deserialize(input)
+      properties_instances.collect do |property|
+        property.serialized_values = input[property.name.to_s]
+      end
+    end
+
+    def properties_structure
+      generate_structure.convert_keys(:to_api).with_indifferent_access
+    end
+
+    # Validate each property_type's property.
+    #
+    # If the property_type doesn't respond to valid?, then it means it must be a
+    # native type, or at least not something which inherits Ninetails::Property, so we will class it
+    # as valid blindly.
+    def valid?
+      validations = properties_instances.collect do |property_type|
+        if property_type.property.respond_to?(:valid?)
+          property_type.property.valid?
+        else
+          true
+        end
+      end
+
+      validations.all?
+    end
+
+    private
+
+    def properties_instances
+      @properties_instances ||= self.class.properties.collect(&:clone)
+    end
+
+    def generate_structure
+      properties_instances.each_with_object({}) do |property_type, hash|
+        hash[:type] = self.class.name.demodulize
+        hash[:reference] = reference
+        hash[property_type.name] = property_type.serialize
+
+        if property_type.property.try(:errors).try(:present?)
+          hash[property_type.name].merge! errors: property_type.property.errors.messages
+        end
+      end
+    end
+
+  end
+end

data/app/components/ninetails/element_definition.rb

@@ -0,0 +1,67 @@
+module Ninetails
+  class ElementDefinition
+    attr_accessor :name, :type, :count, :elements
+
+    delegate :properties, to: :type
+
+    def initialize(name, type, count)
+      @name = name
+      @type = type
+      @count = count
+      @elements = []
+    end
+
+    def add_to_hash(hash)
+      if count == :single
+        hash[name] = single_element_structure
+      else
+        hash[name] = multiple_element_structure
+      end
+    end
+
+    def deserialize(input)
+      self.elements = []
+
+      if input.is_a? Array
+        input.each do |hash|
+          add_element hash
+        end
+      else
+        add_element input
+      end
+    end
+
+    def properties_structure
+      @properties_structure ||= type.new.properties_structure
+    end
+
+    def all_elements_valid?
+      elements.all? &:valid?
+    end
+
+    private
+
+    def single_element_structure
+      if elements.present?
+        elements.first.properties_structure
+      else
+        properties_structure
+      end
+    end
+
+    def multiple_element_structure
+      if elements.present?
+        elements.collect &:properties_structure
+      else
+        [properties_structure]
+      end
+    end
+
+    def add_element(input)
+      element = type.new
+      element.deserialize input
+      elements << element
+    end
+
+  end
+end

data/app/components/ninetails/property.rb

@@ -0,0 +1,11 @@
+module Ninetails
+  class Property
+    include Ninetails::PropertyStore
+
+    def self.serialize
+      properties.each_with_object({}) do |property, hash|
+        hash[property.name] = property.serialize
+      end
+    end
+  end
+end

data/app/components/ninetails/property_store.rb

@@ -0,0 +1,22 @@
+module Ninetails
+  module PropertyStore
+    extend ActiveSupport::Concern
+
+    included do
+      include Virtus.model
+      include ActiveModel::Validations
+    end
+
+    class_methods do
+      def property(name, type)
+        attribute name, type
+        properties << Ninetails::PropertyType.new(name, type)
+      end
+
+      def properties
+        @properties ||= []
+      end
+    end
+
+  end
+end

data/app/components/ninetails/property_type.rb

@@ -0,0 +1,27 @@
+module Ninetails
+  class PropertyType
+    attr_accessor :name, :type, :serialized_values, :property
+
+    def initialize(name, type)
+      @name = name
+      @type = type
+      @property = type.new
+    end
+
+    def serialized_values=(hash)
+      @serialized_values = hash
+      @property = type.new serialized_values
+    end
+
+    def serialize
+      if serialized_values.present?
+        serialized_values
+      elsif type.respond_to? :serialize
+        type.serialize
+      else
+        type.new
+      end
+    end
+
+  end
+end

data/app/components/ninetails/section_template.rb

@@ -0,0 +1,66 @@
+module Ninetails
+  class SectionTemplate
+    ALLOWED_POSITIONS = [:head, :body]
+
+    attr_accessor :elements_instances
+
+    def self.located_in(position)
+      unless ALLOWED_POSITIONS.include?(position)
+        fail SectionConfigurationError, "position must be in #{ALLOWED_POSITIONS}"
+      end
+
+      @position = position
+    end
+
+    def self.position
+      @position
+    end
+
+    def self.has_element(name, type)
+      define_element name, type, :single
+    end
+
+    def self.has_many_elements(name, type)
+      define_element name, type, :multiple
+    end
+
+    def self.elements
+      @elements
+    end
+
+    def self.find_element(name)
+      elements.find { |element| element.name == name.to_sym }
+    end
+
+    def serialize
+      {
+        name: "",
+        type: self.class.name.demodulize,
+        tags: tags,
+        elements: serialize_elements
+      }
+    end
+
+    def tags
+      {
+        position: self.class.position
+      }
+    end
+
+    def serialize_elements
+      elements = elements_instances || self.class.elements
+
+      elements.each_with_object({}) do |element, hash|
+        element.add_to_hash hash
+      end
+    end
+
+    private
+
+    def self.define_element(name, type, count)
+      @elements ||= []
+      @elements << Ninetails::ElementDefinition.new(name, type, count)
+    end
+
+  end
+end

data/app/controllers/ninetails/application_controller.rb

@@ -0,0 +1,4 @@
+module Ninetails
+  class ApplicationController < ActionController::API
+  end
+end

data/app/controllers/ninetails/page_revisions_controller.rb

@@ -0,0 +1,31 @@
+module Ninetails
+  class PageRevisionsController < ApplicationController
+
+    before_action :find_page
+
+    def index
+      render json: { revisions: @page.revisions }
+    end
+
+    def create
+      @page.build_revision_from_params revision_params
+
+      if @page.revision.save
+        render json: @page.to_builder.target!, status: :created
+      else
+        render json: @page.to_builder.target!, status: :bad_request
+      end
+    end
+
+    private
+
+    def find_page
+      @page = Page.find params[:page_id]
+    end
+
+    def revision_params
+      params.require(:page_revision).permit!
+    end
+
+  end
+end

data/app/controllers/ninetails/pages_controller.rb

@@ -0,0 +1,14 @@
+module Ninetails
+  class PagesController < ApplicationController
+
+    def show
+      @page = Page.find_by! url: params[:id]
+      @page.revision = @page.revisions.find params[:revision_id] if params[:revision_id]
+
+      render json: @page.to_builder.target!
+    rescue ActiveRecord::RecordNotFound
+      render json: {}, status: :not_found
+    end
+
+  end
+end

data/app/controllers/ninetails/section_templates_controller.rb

@@ -0,0 +1,17 @@
+module Ninetails
+  class SectionTemplatesController < ApplicationController
+
+    def index
+      templates = Rails.root.join("app", "components", "section_template").children.collect do |entry|
+        entry.basename.to_s.sub(/(\..*)$/, '').classify
+      end
+
+      render json: { templates: templates }
+    end
+
+    def show
+      render json: "SectionTemplate::#{params[:id]}".safe_constantize.new.serialize
+    end
+
+  end
+end

data/app/models/ninetails/page.rb

@@ -0,0 +1,37 @@
+module Ninetails
+  class Page < ActiveRecord::Base
+    has_many :revisions, class_name: "PageRevision"
+    has_one :current_revision, class_name: "PageRevision"
+
+    attr_writer :revision
+
+    def revision
+      @revision || current_revision
+    end
+
+    def to_builder
+      Jbuilder.new do |json|
+        json.page do
+          json.call(self, :id, :name, :url)
+          json.revision_id revision.id
+          json.sections sections_to_builder
+        end
+      end
+    end
+
+    def sections_to_builder
+      revision.sections.collect do |section|
+        section.to_builder.attributes!
+      end
+    end
+
+    def build_revision_from_params(page_revision)
+      self.revision = revisions.build message: page_revision[:message]
+
+      page_revision[:sections].each do |section_json|
+        revision.sections.build section_json.except(:id)
+      end
+    end
+
+  end
+end

data/app/models/ninetails/page_revision.rb

@@ -0,0 +1,28 @@
+module Ninetails
+  class PageRevision < ActiveRecord::Base
+    belongs_to :page
+    has_many :page_revision_sections
+    has_many :sections, through: :page_revision_sections
+
+    validate :sections_are_all_valid
+
+    private
+
+    # Validate all sections and rebuild the sections array with the instances which now
+    # contain error messages
+    def sections_are_all_valid
+      sections.each do |section|
+        deserialized_section = section.deserialize
+
+        deserialized_section.elements_instances.each do |element_definition|
+          unless element_definition.all_elements_valid?
+            errors.add :base, "Element #{element_definition.name} is not valid"
+          end
+        end
+
+        section.elements = deserialized_section.serialize[:elements]
+      end
+    end
+
+  end
+end