breeze_cms 0.9.5

data/app/helpers/breeze/images_helper.rb

@@ -0,0 +1,57 @@
+module Breeze
+
+  module ImagesHelper
+
+    def text_for_index
+      if(section_id)
+        section = Section.find(section_id)
+        "Select image for Section #{section.index} : #{section.header}"
+      elsif(card_id)
+        card = Card.find(card_id)
+        "Select image for Card #{card.index} : #{card.header}"
+      else
+        "All Images"
+      end
+    end
+
+    def text_for_new
+      if(section_id)
+        section = Section.find(section_id)
+        "Add image for Section: #{section.header}"
+      elsif(card_id)
+        card = Card.find(card_id)
+        "Select image for Card: #{card.header}"
+      else
+        "New Image"
+      end
+    end
+
+    def new_link_params
+      if(params[:section_id])
+        return {section_id: params[:section_id]}
+      end
+      if(params[:card_id])
+        return {card_id: params[:card_id]}
+      end
+      nil
+    end
+    def hidden_for_select_image
+      if(section_id)
+        hidden_field_tag :section_id , section_id
+      elsif(card_id)
+        hidden_field_tag :card_id , card_id
+      else
+        ""
+      end
+    end
+
+    private
+    def section_id
+      params[:section_id]
+    end
+    def card_id
+      params[:card_id]
+    end
+
+  end
+end

data/app/helpers/breeze/options_helper.rb

@@ -0,0 +1,120 @@
+module Breeze
+  module OptionsHelper
+
+    # use options with as many option names as neccessary
+    def options(section, *args )
+      all = {}
+      extra_class = ""
+      extra_class = args.pop if args.last.is_a?(String)
+      args.each do |option_name|
+        hash = send "#{option_name}_option".to_sym , section
+        all.merge!(hash) { |key, one, two| one.to_s + " " + two.to_s }
+      end
+      all[:class] = all[:class] + " #{extra_class}"
+      all
+    end
+
+    def date_precision(element , date_name)
+      precision = element.option("date_precision")
+      date = element.option(date_name)
+      if( precision == "precise")
+        return date.to_formatted_s(:short) + " " + date.year.to_s
+      end
+      return Date.today if date.blank?
+      if(date.day < 10)
+        attr = "Beginning"
+      elsif date.day < 20
+        attr = "Middle"
+      else
+        attr = "End"
+      end
+      "#{attr} of #{date.strftime('%B')} #{date.year}"
+    end
+
+    # adds prose irrespective of options
+    def prose_option(section)
+      prose_classes
+    end
+
+    def order_option(section , clazz = "")
+      if section.has_option?("order")
+        clazz += " order-last" if section.option('order') == "right"
+      end
+      {class: clazz}
+    end
+
+    def text_align_option(section , clazz = "")
+      if section.has_option?("text_align")
+        # text-center , text-left , text-right , leave comment for tailwind
+        clazz += " text-#{section.option('text_align')}"
+      end
+      {class: clazz}
+    end
+
+    def item_align_option(section , clazz = "")
+      if section.has_option?("item_align")
+        case section.option("item_align")
+        when "left"
+          clazz += " " + " justify-start"
+        when "right"
+          clazz += " " + " justify-end"
+        else
+          clazz += " " + " justify-center"
+        end
+      end
+      {class: clazz }
+    end
+
+    def background_option(section , clazz = "")
+      if section.has_option?("background")
+        option = section.option('background')
+        clazz += " " + (Breeze.background[section.option('background')] || "")
+      end
+      {class: clazz}
+    end
+
+    def margin_option(section , clazz = "")
+      return {class: clazz} unless section.has_option?("margin")
+      margin = Breeze.margin[section.option("margin")] || ""
+      {class: clazz + margin}
+    end
+
+    def text_color_option(section , clazz = "")
+      if section.has_option?("text_color")
+        clazz += " " + (Breeze.text_color[section.option("text_color")] || "")
+      end
+      {class: clazz }
+    end
+
+    def shade_option(section , clazz = "")
+      if section.has_option?("shade_color")
+        clazz += " " + (Breeze.shade_color[section.option("shade_color")] || "")
+      end
+      {class: clazz }
+    end
+
+    def text_columns_option( section , clazz = "")
+      if section.has_option?("text_columns")
+        clazz += " " + (Breeze.text_columns[section.option("text_columns")] || "")
+      end
+      {class: clazz }
+    end
+
+    def slider_columns_option( section , clazz = "")
+      if section.has_option?("slider_columns")
+        Breeze.slider_columns[section.option("slider_columns")]
+      else
+        Breeze.slider_columns["1"]
+      end
+    end
+
+    def column_option( section , clazz = "" )
+      if section.has_option?("columns")
+        clazz += " " + (Breeze.columns[section.option("columns")] || "")
+      end
+      {class: clazz }
+    end
+
+
+  end
+end

data/app/helpers/breeze/pages_helper.rb

@@ -0,0 +1,5 @@
+module Breeze
+  module PagesHelper
+    include ViewHelper #for previews
+  end
+end

data/app/helpers/breeze/sections_helper.rb

@@ -0,0 +1,14 @@
+module Breeze
+  module SectionsHelper
+    include ViewHelper #for previews
+
+    #image tag for the preview, passing options through
+    def section_preview(section , options)
+      image_tag("breeze/section_preview/#{section.template}" , options)
+    end
+
+    def card_preview(section , options)
+      image_tag("breeze/card_preview/#{section.card_template}" , options)
+    end
+  end
+end

data/app/helpers/breeze/styles_helper.rb

@@ -0,0 +1,4 @@
+module Breeze
+  module StylesHelper
+  end
+end

data/app/helpers/breeze/translations_helper.rb

@@ -0,0 +1,14 @@
+module Breeze
+  module TranslationsHelper
+    def language_bg lang
+      case lang
+      when "fi"
+        "border-blue-800"
+      when "sv"
+        "border-yellow-400"
+      else
+        ""
+      end
+    end
+  end
+end

data/app/helpers/breeze/view_helper.rb

@@ -0,0 +1,74 @@
+module Breeze
+  module ViewHelper
+    include BreezeHelper
+
+    def current_lang
+      params[:lang]
+    end
+
+    def render_section(section)
+      template = "breeze/view/" + section.template
+      render( template , section: section)
+    end
+
+    # background image as inline style
+    def bg(section , clazz = "")
+      return {class: clazz} if section.image.blank?
+      img = asset_url( section.image.asset_name )
+      style = "background-image: url('#{img}');"
+      if(section.option("fixed") == "on")
+        clazz += " bg-fixed"
+      end
+      if(align = section.option("image_align"))
+        # for tailwind: bg-left-top bg-left bg-left-bottom
+        # bg-top bg-center bg-bottom bg-right-top bg-right bg-right-bottom
+        clazz += " bg-#{align}"
+      end
+      {class: clazz , style: style}
+    end
+
+    # works for with sections and cards that respond to .image
+    def image_for(element , classes = "")
+      return "" if element.image.blank?
+      image = element.image
+      image_tag(image.asset_name , alt: image.name , class: classes )
+    end
+
+    def button_classes
+      "inline-block rounded-lg px-3 py-2 text-base font-medium border border-gray-500 hover:border-black"
+    end
+
+    def view_button(element , extra_classes = "")
+      return "" unless element.has_option?("button_link")
+      ["<button class='#{button_classes} ",
+        extra_classes,
+        "'>" ,
+        "<a href='" ,
+        element.option("button_link") ,
+        "'>" ,
+        element.option("button_text") ,
+        "</a>",
+      " </button>"].join.html_safe
+    end
+    # just for tailwind bg-cyan-200
+
+    def self.last_blog
+      blog = Page.find_by_type(:blog)
+      return  nil unless blog
+      blog.sections.last
+    end
+    def last_blog
+      PagesHelper.last_blog
+    end
+
+    def header_list
+      return "" unless blog_section = last_blog
+      blog = blog_section.page
+      headers = blog.sections.collect{|s| "- " + s.header}
+      headers.shift
+      return "" if headers.empty?
+      markdown headers.join("\n")
+    end
+
+  end
+end

data/app/jobs/breeze/application_job.rb

@@ -0,0 +1,4 @@
+module Breeze
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/breeze/application_mailer.rb

@@ -0,0 +1,6 @@
+module Breeze
+  class ApplicationMailer < ActionMailer::Base
+    default from: "from@example.com"
+    layout "mailer"
+  end
+end

data/app/models/breeze/active_base.rb

@@ -0,0 +1,34 @@
+module Breeze
+  class ActiveBase < ActiveYaml
+    fields :updated_at , :updated_by
+
+    def edit_save( editor )
+      self.updated_at = Time.now
+      self.updated_by = editor
+      edit_save!(editor)
+    end
+
+    def edit_save!(editor)
+      ChangeSet.current.edit(self.class.name , self.change_name, editor)
+      self.class.save_all
+    end
+
+    def add_save( editor )
+      self.updated_at = Time.now
+      self.updated_by = editor
+      add_save!(editor)
+    end
+
+    def add_save!(editor)
+      ChangeSet.current.add(self.class.name , self.change_name, editor)
+      self.class.save_all
+    end
+
+    def delete_save!(editor)
+      ChangeSet.current.delete(self.class.name , self.change_name,editor)
+      self.class.delete(self.id)
+      self.class.save_all
+    end
+
+  end
+end

data/app/models/breeze/active_yaml.rb

@@ -0,0 +1,143 @@
+module Breeze
+  class ActiveYaml
+    attr :data   #data of the instance, hash
+
+    # retain the given hash data instance
+    def initialize(data)
+      @data = data
+      # some checks, eg values are only fields
+    end
+
+    def id
+      data[:id]
+    end
+    def id=(new_id)
+      raise "Id must be number not (#{new_id})" unless new_id.is_a?(Integer)
+      data[:id] = new_id
+    end
+
+    extend ActiveModel::Naming
+    include ActiveModel::Conversion
+
+    def persisted?
+      true
+    end
+
+    class_attribute :path # usually rails root, where data is stored
+    class_attribute :yaml_file   # the loaded data as array
+    class_attribute :field_names  # methos name for accessing / allowed fields
+
+    class << self
+      #return all yaml data converted
+      def all
+        self.reload if self.yaml_file.blank?
+        yaml_file.collect{|item| self.new(item) }
+      end
+
+      def primary_key
+        "id"
+      end
+
+      # loads the data from path, name implicit in class_name
+      def set_root_path(path)
+        self.path = path
+      end
+
+      def reload
+        self.yaml_file = load_file
+      end
+
+      def first
+        self.new(yaml_file.first)
+      end
+
+      def find( id )
+        id = id.to_i unless id.is_a?(Integer)
+        find_by( :id , id )
+      end
+
+      def find_by( field , value )
+        found = yaml_file.detect { |record| record[field] == value }
+        return nil unless found
+        self.new(found)
+      end
+
+      def find_all( field , value )
+        found = yaml_file.find_all { |record| record[field] == value }
+        found.collect {|f| self.new(f)}
+      end
+
+      def define_access(field)
+        define_method(field) do
+          data[field]
+        end
+        define_method(:"#{field}=") do |new_val|
+          data[field] = new_val
+        end
+        assoc , id = field.to_s.split("_") # ie field image_id
+        define_association(assoc) if id == "id"  #creates method image
+      end
+
+      # aka belongs_to
+      # define a method by given name that used id value and
+      # name of association to get a model instance of the id
+      def define_association(assoc)
+        clazz = "Breeze::#{assoc.to_s.capitalize}".constantize
+        define_method(assoc) do
+          id = data[:"#{assoc}_id"]
+          clazz.find( id )
+        end
+      end
+
+      # class defines fields, we define access methods and finder for each
+      def fields(*fields)
+        self.field_names = fields
+        raise "Fields must be Array not #{fields.class}" unless fields.is_a?(Array)
+        fields.each do |field|
+          define_access(field)
+          the_meta_class.define_method(:"find_by_#{field}") do |arg|
+            find_by(field , arg)
+          end
+        end
+      end
+
+      # load the yaml data from path and class_name
+      def load_file
+        YAML.load(File.read(full_path) , permitted_classes: [Time , Symbol],aliases: true)
+      end
+
+      # filename for the data (load and save)
+      # made up of the set dir (set_root_path) plus tableized class name
+      def full_path
+        mod , filename = self.name.split("::").collect{|p| p.underscore}
+        full_name = mod + "/" + filename.tableize + ".yml"
+        File.join(self.path , full_name )
+      end
+
+      #create a new data point by adding the hash
+      def append(data)
+        largest = 0
+        yaml_file.each { |item| largest = item[:id] if item[:id] > largest }
+        data[:id] = largest + 1
+        yaml_file << data
+        largest + 1
+      end
+
+      def save_all
+        File.write( full_path , yaml_file.to_yaml)
+      end
+
+      def delete(id)
+        yaml_file.delete_if{|record| record[:id] == id.to_i}
+        true
+      end
+
+      def the_meta_class
+        class << self
+          self
+        end
+      end
+
+    end
+  end
+end

data/app/models/breeze/card.rb

@@ -0,0 +1,90 @@
+module Breeze
+
+  class Card < ViewBase
+
+    set_root_path Rails.root.join(Breeze.data_dir)
+
+    fields  :id , :index , :section_id
+    fields  :text , :header, :image_name
+
+    def change_name
+      pagename = section ? section.page_name : section_id.to_s
+      "#{pagename}:#{header}"
+    end
+
+    def missing_translations
+      sum = 0
+      Breeze.language_strings.each do |lang|
+        sum += 1 if get_translation(lang)&.is_old?
+      end
+      sum
+    end
+
+    def move_up
+      swap_index_with(previous_card)
+    end
+
+    def move_down
+      swap_index_with(next_card)
+    end
+
+    def previous_card
+      section.cards.find{|card| card.index == index - 1}
+    end
+
+    def next_card
+      section.cards.find{|card| card.index == index + 1}
+    end
+
+    # card templates are stored in the section so the all cards
+    # have the same
+    def template
+      section.card_template
+    end
+
+    def template_style
+      CardStyle.find_by_template( self.template )
+    end
+
+    def allowed_fields
+      super + [:section_id]
+    end
+
+    def delete_and_reset_index(editor)
+      delete_save!(editor)
+      Section.find(section_id).reset_index
+      Card.save_all
+    end
+
+    def object_type
+      "Card"
+    end
+
+    def index_name
+      "#{section.index}.#{self.index}"
+    end
+
+    def delete(editor)
+      delete_translations(editor)
+      delete_save!(editor)
+    end
+
+    def self.new_card(card_template , section_id , index)
+      data = { section_id: section_id , index: index}
+      template = CardStyle.find_by_template( card_template )
+      template.fields.each do |key|
+        data[key.to_sym] = "NEW"
+      end
+      new_id = Card.append(data)
+      card = Card.new(data)
+      card.add_default_options(template.options_definitions)
+      card
+    end
+
+    def self.reload
+      res = super()
+      self.fix_translations
+    end
+
+  end
+end

data/app/models/breeze/card_style.rb

@@ -0,0 +1,12 @@
+module Breeze
+  class CardStyle < Style
+    set_root_path Rails.root.join(Breeze.data_dir)
+
+    fields  :template , :text , :header, :fields
+
+    def card_preview
+      "breeze/card_preview/" + template
+    end
+
+  end
+end

data/app/models/breeze/change_set.rb

@@ -0,0 +1,58 @@
+module Breeze
+  class ChangeSet
+
+
+    def self.current
+      @@current ||= ChangeSet.new
+    end
+    attr_reader :adds , :edits , :deletes , :last , :last_editor
+
+    def initialize
+      zero
+    end
+
+    def zero
+      @adds = Set.new
+      @edits = Set.new
+      @deletes = Set.new
+      @last = nil
+      @last_editor = nil
+    end
+
+    def touch(editor)
+      @last = Time.now
+      @last_editor = editor
+    end
+
+    def add( type , text , editor)
+      touch(editor)
+      @adds << [typed(type) , text ]
+    end
+
+    def edit( type , text, editor)
+      touch(editor)
+      @edits << [typed(type) , text ]
+    end
+    def delete( type , text, editor)
+      touch(editor)
+      @deletes << [typed(type) , text ]
+    end
+
+    def added( type )
+      type = type.to_sym
+      @adds.select { |a| a.first == type }
+    end
+    def edited( type )
+      type = type.to_sym
+      @edits.select { |a| a.first == type }
+    end
+    def deleted( type )
+      type = type.to_sym
+      @deletes.select { |a| a.first == type }
+    end
+
+    def typed(class_name)
+      class_name.split("::").last.to_sym
+    end
+  end
+end