trusty-cms 1.0.0

data/lib/tasks/translate.rake

@@ -0,0 +1,59 @@
+namespace :radiant do
+  namespace :i18n do
+    
+    desc "Syncs all available translations to the English master"
+    task :sync => :environment do
+      # All places TrustyCms can store locales
+      locale_paths = TrustyCms::AvailableLocales.locale_paths
+      # The main translation root, basically where English is kept
+      language_root = "#{TRUSTY_CMS_ROOT}/config/locales"
+      words = TranslationSupport.get_translation_keys(language_root)
+      locale_paths.each do |path|
+        if path == language_root || path.match('language_pack')
+          Dir["#{path}/*.yml"].each do |filename|
+            next if filename.match('_available_tags')
+            basename = File.basename(filename, '.yml')
+            puts "Syncing #{basename}"
+            (comments, other) = TranslationSupport.read_file(filename, basename)
+            words.each { |k,v| other[k] ||= words[k] }  # Initializing hash variable as empty if it does not exist
+            other.delete_if { |k,v| !words[k] }         # Remove if not defined in en.yml
+            TranslationSupport.write_file(filename, basename, comments, other)
+          end
+        end 
+      end
+    end
+    
+    desc "Creates or updates the English available tag descriptions"
+    task :available_tags => :environment do
+      descriptions = Hash.new
+      Page.tag_descriptions.sort.each do |tag, desc|
+        tag = '    ' + tag.gsub(':','-') + ':'
+        desc = desc.gsub('    ','      ')
+        descriptions[tag] = ' "' + desc.gsub('%','%').gsub('"','\"').strip + '"'
+      end 
+      comments = ''
+      TranslationSupport.write_file("#{TRUSTY_CMS_ROOT}/config/locales/en_available_tags.yml","---\nen:\n  desc",comments,descriptions)
+    end 
+    
+    desc "Syncs all translations available_tags to the English master"
+    task :sync_available_tags => :environment do
+      # All places TrustyCms can store locales
+      locale_paths = TrustyCms::AvailableLocales.locale_paths
+      # The main translation root, basically where English is kept
+      language_root = "#{TRUSTY_CMS_ROOT}/config/locales"
+      words = TranslationSupport.open_available_tags("#{language_root}/en_available_tags.yml")
+      locale_paths.each do |path|
+        if path == language_root || path.match('language_pack')
+          Dir["#{path}/*.yml"].each do |filename|
+            next unless filename.match('_available_tags')
+            basename = File.basename(filename, '_available_tags.yml')
+            puts "Syncing #{basename}"
+            (comments, other) = TranslationSupport.open_available_tags(filename)
+            puts other
+          end
+        end 
+      end
+    end         
+    
+  end
+end

data/lib/tasks/undefine.rake

@@ -0,0 +1,28 @@
+# # Undefined unneeded tasks in instance mode
+# unless TrustyCms.app?
+#   def undefine_task(*names)
+#     app = Rake.application
+#     tasks = app.instance_variable_get('@tasks')
+#     names.flatten.each { |name| tasks.delete(name) }
+#   end
+#
+#   undefine_task %w(
+#     radiant:clobber_package
+#     radiant:install_gem
+#     radiant:package
+#     radiant:release
+#     radiant:repackage
+#     radiant:uninstall_gem
+#     radiant:import:prototype:stylesheets
+#     radiant:import:prototype:images
+#     radiant:import:prototype:javascripts
+#     radiant:import:prototype:assets
+#     rails:freeze:edge
+#     rails:freeze:gems
+#     rails:unfreeze
+#     rails:update
+#     rails:update:configs
+#     rails:update:javascripts
+#     rails:update:scripts
+#   )
+# end

data/lib/translation_support.rb

@@ -0,0 +1,54 @@
+class TranslationSupport
+  class << self
+    
+    #Retrieve US word set
+    def get_translation_keys(language_root, suffix=nil)
+      (dummy_comments, words) = read_file("#{language_root}/en#{suffix}.yml", 'en')
+      words
+    end
+    
+    #Retrieve comments, translation data in hash form
+    def read_file(filename, basename)
+      (comments, data) = IO.read(filename).split(/\n#{basename}:\s*\n/)   #Add error checking for failed file read?
+      return comments, create_hash(data, basename)
+    end
+    
+    #Creates hash of translation data
+    def create_hash(data, basename)
+      words = Hash.new
+      return words if !data
+      parent = Array.new
+      previous_key = 'base'
+      data.split("\n").each do |w|
+        next if w.strip.blank?
+        (key, value) = w.split(':', 2)
+        value ||= ''
+        shift = (key =~ /\w/)/2 - parent.size                             #Determine level of current key in comparison to parent array
+        key = key.sub(/^\s+/,'')
+        parent << previous_key if shift > 0                               #If key is child of previous key, add previous key as parent
+        (shift * -1).times { parent.pop } if shift < 0                      #If key is not related to previous key, remove parent keys
+        previous_key = key                                                #Track key in case next key is child of this key
+        words[parent.join(':') + ':' + key] = value unless key.blank?
+      end
+      words
+    end
+    
+    def open_available_tags(filename)
+      data = YAML::load(File.open("#{filename}"))
+      data.to_s
+    end
+    
+    #Writes to file from translation data hash structure
+    def write_file(filename,basename,comments,words)
+      File.open(filename, "w") do |log|
+        log.puts(comments+"\n"+basename+": \n")
+        words.sort.each do |k,v|
+          keys = k.split(':')
+          (keys.size-1).times { keys[keys.size-1] = '  ' + keys[keys.size-1] }   #Add indentation for children keys
+          log.puts(keys[keys.size-1]+':'+v+"\n")
+        end
+      end
+    end
+    
+  end
+end

data/lib/trusty_cms/admin_ui/region_partials.rb

@@ -0,0 +1,23 @@
+class TrustyCms::AdminUI::RegionPartials
+  def initialize(template)
+    @partials = Hash.new {|h,k| h[k] = "<strong>`#{k}' default partial not found!</strong>" }
+    @template = template
+  end
+  
+  def [](key)
+    @partials[key.to_s]
+  end
+  
+  def method_missing(method, *args, &block)
+    if block_given?
+      # Ruby 1.9.2 yields self in instance_eval... see https://gist.github.com/479572
+      # lambdas are as strict as methods in 1.9.x, making sure that the args match, Procs are not.
+      if RUBY_VERSION =~ /^1\.9/ and block.lambda? and block.arity != 1
+        raise "You can only pass a proc ('Proc.new') or a lambda that takes exactly one arg (for self) to TrustyCms::AdminUI::RegionPartials' method_missing."
+      end
+      @partials[method.to_s] = @template.capture(&block)
+    else
+      @partials[method.to_s]
+    end
+  end
+end

data/lib/trusty_cms/admin_ui/region_set.rb

@@ -0,0 +1,35 @@
+class TrustyCms::AdminUI::RegionSet
+
+  def initialize
+    @regions = Hash.new do |h,k|
+      h[k] = []
+    end
+    yield self if block_given?
+  end
+  
+  def [](region)
+    @regions[region.to_sym]
+  end
+  
+  def add(region=nil, partial=nil, options={})
+    raise ArgumentError, "You must specify a region and a partial" unless region and partial
+    if options[:before]
+      index = @regions[region].empty? ? 0 : (@regions[region].index(options[:before]) || @regions[region].size)
+      self[region].insert(index, partial)
+    elsif options[:after]
+      index = @regions[region].empty? ? 0 : (@regions[region].index(options[:after]) || @regions[region].size - 1)
+      self[region].insert(index + 1, partial)
+    else
+      self[region] << partial
+    end
+  end
+  
+  def method_missing(method, *args, &block)
+    if args.empty?
+      self[method]
+    else
+      super
+    end
+  end
+  
+end

data/lib/trusty_cms/admin_ui.rb

@@ -0,0 +1,244 @@
+require 'simpleton'
+require 'ostruct'
+
+module TrustyCms
+  class AdminUI
+    # This may be loaded before ActiveSupport, so do an explicit require
+    require 'trusty_cms/admin_ui/region_set'
+    
+    class DuplicateTabNameError < StandardError; end
+    
+    # The NavTab Class holds the structure of a navigation tab (including
+    # its sub-nav items).
+    class NavTab < Array
+      attr_reader :name
+      
+      def initialize(name)
+        @name = name
+      end
+      
+      def [](id)
+        unless id.kind_of? Fixnum
+          self.find {|subnav_item| subnav_item.name.to_s.titleize == id.to_s.titleize }
+        else
+          super
+        end
+      end
+      
+      def <<(*args)
+        options = args.extract_options!
+        item = args.size > 1 ? deprecated_add(*(args << caller)) : args.first
+        raise DuplicateTabNameError.new("duplicate tab name `#{item.name}'") if self[item.name]
+        item.tab = self if item.respond_to?(:tab=)
+        if options.empty?
+          super(item)
+        else
+          options.symbolize_keys!
+          before = options.delete(:before)
+          after = options.delete(:after)
+          tab_name = before || after
+          if self[tab_name]
+            _index = index(self[tab_name])
+            _index += 1 unless before
+            insert(_index, item)
+          else
+            super(item)
+          end
+        end
+      end
+      
+      alias :add :<<
+      
+      def add_item(*args)
+        options = args.extract_options!
+        options.symbolize_keys!
+        before = options.delete(:before)
+        after = options.delete(:after)
+        tab_name = before || after
+        if self[tab_name]
+          _index = index(self[tab_name])
+          _index += 1 unless before
+          insert(_index, NavSubItem.new(args.first, args.second))
+        else
+          add NavSubItem.new(args.first, args.second)
+        end
+      end
+      
+      def visible?(user)
+        any? { |sub_item| sub_item.visible?(user) }
+      end
+      
+      def deprecated_add(name, url, caller)
+        ActiveSupport::Deprecation.warn("admin.tabs.add is no longer supported in TrustyCms 0.9.x.  Please update your code to use: \ntab \"Content\" do\n\tadd_item(...)\nend", caller)
+        NavSubItem.new(name, url)
+      end
+    end
+    
+    # Simple structure for storing the properties of a tab's sub items.
+    class NavSubItem
+      attr_reader :name, :url
+      attr_accessor :tab
+      
+      def initialize(name, url = "#")
+        @name, @url = name, url
+      end
+      
+      def visible?(user)
+        visible_by_controller?(user)
+      end
+      
+      def relative_url
+        File.join(ActionController::Base.relative_url_root || '', url)
+      end
+      
+      private
+      def visible_by_controller?(user)
+        params = ActionController::Routing::Routes.recognize_path(url, :method => :get)
+        if params && params[:controller]
+          klass = "#{params[:controller].camelize}Controller".constantize
+          klass.user_has_access_to_action?(user, params[:action])
+        else
+          false
+        end
+      end
+    end
+    
+    include Simpleton
+    
+    attr_accessor :nav
+    
+    def nav_tab(*args)
+      NavTab.new(*args)
+    end
+    
+    def nav_item(*args)
+      NavSubItem.new(*args)
+    end
+    
+    def tabs
+      nav['Content']
+    end
+    
+    # Region sets
+    %w{page layout user configuration extension}.each do |controller|
+      attr_accessor controller
+      alias_method "#{controller}s", controller
+    end
+    
+    def initialize
+      initialize_nav
+      load_default_regions
+    end
+    
+    def initialize_nav
+      @nav = NavTab.new("Tab Container")
+      load_default_nav
+    end
+    
+    def load_default_nav
+      content = nav_tab("Content")
+      content << nav_item("Pages", "/admin/pages")
+      nav << content
+      
+      design = nav_tab("Design")
+      design << nav_item("Layouts", "/admin/layouts")
+      nav << design
+      
+      settings = nav_tab("Settings")
+      settings << nav_item("General", "/admin/configuration")
+      settings << nav_item("Personal", "/admin/preferences")
+      settings << nav_item("Users", "/admin/users")
+      settings << nav_item("Extensions", "/admin/extensions")
+      nav << settings
+    end
+    
+    def load_default_regions
+      @page = load_default_page_regions
+      @layout = load_default_layout_regions
+      @user = load_default_user_regions
+      @configuration = load_default_configuration_regions
+      @extension = load_default_extension_regions
+    end
+    
+    private
+    
+    def load_default_page_regions
+      OpenStruct.new.tap do |page|
+        page.edit = RegionSet.new do |edit|
+          edit.main.concat %w{edit_header edit_form edit_popups}
+          edit.form.concat %w{edit_title edit_extended_metadata edit_page_parts}
+          edit.layout.concat %w{edit_layout edit_type edit_status edit_published_at}
+          edit.form_bottom.concat %w{edit_buttons edit_timestamp}
+        end
+        page.index = RegionSet.new do |index|
+          index.sitemap_head.concat %w{title_column_header status_column_header actions_column_header}
+          index.node.concat %w{title_column status_column actions_column}
+        end
+        page.remove = page.children = page.index
+        page.new = page._part = page.edit
+      end
+    end
+    
+    def load_default_user_regions
+      OpenStruct.new.tap do |user|
+        user.preferences = RegionSet.new do |preferences|
+          preferences.main.concat %w{edit_header edit_form}
+          preferences.form.concat %w{edit_name edit_email edit_username edit_password edit_locale}
+          preferences.form_bottom.concat %w{edit_buttons}
+        end
+        user.edit = RegionSet.new do |edit|
+          edit.main.concat %w{edit_header edit_form}
+          edit.form.concat %w{edit_name edit_email edit_username edit_password
+                              edit_roles edit_locale edit_notes}
+          edit.form_bottom.concat %w{edit_buttons edit_timestamp}
+        end
+        user.index = RegionSet.new do |index|
+          index.thead.concat %w{title_header roles_header actions_header}
+          index.tbody.concat %w{title_cell roles_cell actions_cell}
+          index.bottom.concat %w{new_button}
+        end
+        user.new = user.edit
+      end
+    end
+    
+    def load_default_layout_regions
+      OpenStruct.new.tap do |layout|
+        layout.edit = RegionSet.new do |edit|
+          edit.main.concat %w{edit_header edit_form}
+          edit.form.concat %w{edit_title edit_extended_metadata edit_content}
+          edit.form_bottom.concat %w{reference_links edit_buttons edit_timestamp}
+        end
+        layout.index = RegionSet.new do |index|
+          index.top.concat %w{}
+          index.thead.concat %w{title_header actions_header}
+          index.tbody.concat %w{title_cell actions_cell}
+          index.bottom.concat %w{new_button}
+        end
+        layout.new = layout.edit
+      end
+    end
+    
+    def load_default_configuration_regions
+      OpenStruct.new.tap do |configuration|
+        configuration.show = RegionSet.new do |show|
+          show.user.concat %w{preferences}
+          show.config.concat %w{site defaults users}
+        end
+        configuration.edit = RegionSet.new do |edit|
+          edit.main.concat %w{edit_header edit_form}
+          edit.form.concat %w{edit_site edit_defaults edit_users}
+          edit.form_bottom.concat %w{edit_buttons}
+        end
+      end
+    end
+    
+    def load_default_extension_regions
+      OpenStruct.new.tap do |extension|
+        extension.index = RegionSet.new do |index|
+          index.thead.concat %w{title_header website_header version_header}
+          index.tbody.concat %w{title_cell website_cell version_cell}
+        end
+      end
+    end
+  end
+end

data/lib/trusty_cms/available_locales.rb

@@ -0,0 +1,19 @@
+module TrustyCms::AvailableLocales
+  
+  # Returns the list of available locale files in options_for_select format.
+  #
+  def self.locales
+    available_locales = {}
+    TrustyCms.configuration.i18n.load_path.each do |path|
+      if File.exists?(path) && path !~ /_available_tags/
+        locale_yaml = YAML.load_file(path)
+        stem = File.basename(path, '.yml')
+        if locale_yaml[stem] && lang = locale_yaml[stem]["this_file_language"]
+          available_locales[lang] = stem
+        end
+      end
+    end
+    available_locales.collect {|k,v| [k, v]}.sort_by { |s| s[0] }
+  end
+
+end

data/lib/trusty_cms/cache.rb

@@ -0,0 +1,100 @@
+require 'rack/cache'
+# So we can subclass the storage types
+require 'rack/cache/storage'
+require 'rack/cache/metastore'
+require 'rack/cache/entitystore'
+
+module TrustyCms
+  module Cache
+    mattr_accessor :meta_stores, :entity_stores, :use_x_sendfile, :use_x_accel_redirect
+    self.meta_stores ||= []
+    self.entity_stores ||= []
+    self.use_x_sendfile = false
+    self.use_x_accel_redirect = nil
+
+    def self.new(app, options={})
+      self.use_x_sendfile = options.delete(:use_x_sendfile) if options[:use_x_sendfile]
+      self.use_x_accel_redirect = options.delete(:use_x_accel_redirect) if options[:use_x_accel_redirect]
+      Rack::Cache.new(app, {
+          :private_headers => ['Authorization'],
+          :entitystore => "radiant:tmp/cache/entity",
+          :metastore => "radiant:tmp/cache/meta",
+          :verbose => false,
+          :allow_reload => false,
+          :allow_revalidate => false}.merge(options))
+    end
+
+    def self.clear
+      meta_stores.each {|ms| ms.clear }
+      entity_stores.each {|es| es.clear }
+    end
+
+    class EntityStore < Rack::Cache::EntityStore::Disk
+      def initialize(root="#{Rails.root}/tmp/cache/entity")
+        super
+        TrustyCms::Cache.entity_stores << self
+      end
+
+      def clear
+        Dir[File.join(self.root, "*")].each {|file| FileUtils.rm_rf(file) }
+      end
+      
+      def write(body)
+        # Verify that the cache directory exists before attempting to write
+        FileUtils.mkdir_p(self.root, :mode => 0755) unless File.directory?(self.root)
+        super
+      end
+    end
+
+    class MetaStore < Rack::Cache::MetaStore::Disk
+      def initialize(root="#{Rails.root}/tmp/cache/meta")
+        super
+        TrustyCms::Cache.meta_stores << self
+      end
+
+      def clear
+        Dir[File.join(self.root, "*")].each {|file| FileUtils.rm_rf(file) }
+      end
+
+      def store(request, response, entitystore)
+        # Verify that the cache directory exists before attempting to store
+        FileUtils.mkdir_p(self.root, :mode => 0755) unless File.directory?(self.root)
+        super
+      end
+
+      private
+      def restore_response(hash, body=nil)
+        # Cribbed from the Rack::Cache source
+        status = hash.delete('X-Status').to_i
+        response = Rack::Cache::Response.new(status, hash, body)
+
+        # Add acceleration headers
+        if TrustyCms::Cache.use_x_sendfile
+          accelerate(response, 'X-Sendfile', File.expand_path(body.path))
+        elsif TrustyCms::Cache.use_x_accel_redirect
+          virtual_path = File.expand_path(body.path)
+          entity_path = File.expand_path(TrustyCms::Cache.entity_stores.first.root)
+          virtual_path[entity_path] = TrustyCms::Cache.use_x_accel_redirect
+          accelerate(response,'X-Accel-Redirect', virtual_path)
+        end
+        response
+      end
+
+      def accelerate(response, header, value)
+        response.headers[header] = value
+        response.body = []
+        response.headers['Content-Length'] = '0'
+      end
+    end
+  end
+end
+
+# Rack::Cache will look for a constant matching the uri scheme given to the :metastore and :entitystore options
+# when initialising the Middleware
+class Rack::Cache::EntityStore
+  RADIANT = TrustyCms::Cache::EntityStore
+end
+
+class Rack::Cache::MetaStore
+  RADIANT = TrustyCms::Cache::MetaStore
+end