trusty-cms 1.0.0

data/lib/trusty_cms/config/definition.rb

@@ -0,0 +1,142 @@
+module TrustyCms
+  class Config
+    class Definition
+      
+      attr_reader :empty, :default, :type, :notes, :validate_with, :select_from, :allow_blank, :allow_display, :allow_change, :units, :definer
+
+      # Configuration 'definitions' are metadata held in memory that add restriction and description to individual config entries.
+      #
+      # By default radiant's configuration machinery is open and ad-hoc: config items are just globally-accessible variables.
+      # They're created when first mentioned and then available in all parts of the application. The definition mechanism is a way 
+      # to place limits on that behavior. It allows you to protect a config entry, to specify the values it can take and to 
+      # validate it when it changes. In the next update it will also allow you to declare that
+      # a config item is global or site-specific.
+      #
+      # The actual defining is done by TrustyCms::Config#define and usually in a block like this:
+      #
+      #   TrustyCms::Config.prepare do |config|
+      #     config.namespace('users', :allow_change => true) do |users|
+      #       users.define 'allow_password_reset?', :label => 'Allow password reset?'
+      #     end
+      #   end
+      #
+      # See the method documentation in TrustyCms::Config for options and conventions.
+      #
+      def initialize(options={})
+        [:empty, :default, :type, :notes, :validate_with, :select_from, :allow_blank, :allow_change, :allow_display, :units, :definer].each do |attribute|
+          instance_variable_set "@#{attribute}".to_sym, options[attribute]
+        end
+      end
+      
+      # Returns true if the definition included an :empty flag, which should only be the case for the blank, unrestricting
+      # definitions created when an undefined config item is set or got.
+      #
+      def empty?
+        !!empty
+      end
+      
+      # Returns true if the definition included a :type => :boolean parameter. Config entries that end in '?' are automatically 
+      # considered boolean, whether a type is declared or not. config.boolean? may therefore differ from config.definition.boolean?
+      #
+      def boolean?
+        type == :boolean
+      end
+      
+      # Returns true if the definition included a :select_from parameter (either as list or proc).
+      #
+      def selector?
+        !select_from.blank?   
+      end
+      
+      # Returns true if the definition included a :type => :integer parameter
+      def integer?
+        type == :integer
+      end
+      
+      # Returns the list of possible values for this config entry in a form suitable for passing to options_for_select.
+      # if :select_from is a proc it is called first with no arguments and its return value passed through.
+      #
+      def selection
+        if selector?
+          choices = select_from
+          choices = choices.call if choices.respond_to? :call
+          choices = normalize_selection(choices)
+          choices.unshift ["",""] if allow_blank?
+          choices
+        end
+      end
+      
+      # in definitions we accept anything that options_for_select would normally take
+      # here we standardises on an options array-of-arrays so that it's easier to validate input
+      #
+      def normalize_selection(choices)
+        choices = choices.to_a if Hash === choices
+        choices = choices.collect{|c| (c.is_a? Array) ? c : [c,c]}
+      end
+      
+      # If the config item is a selector and :select_from specifies [name, value] pairs (as hash or array), 
+      # this will return the name corresponding to the currently selected value.
+      #
+      def selected(value)
+        if value && selector? && pair = selection.find{|s| s.last == value}
+          pair.first
+        end
+      end
+      
+      # Checks the supplied value against the validation rules for this definition.
+      # There are several ways in which validations might be defined or implied:
+      # * if :validate_with specifies a block, the setting object is passed to the block
+      # * if :type is :integer, we test that the supplied string resolves to a valid integer
+      # * if the config item is a selector we test that its value is one of the permitted options
+      # * if :allow_blank has been set to false, we test that the value is not blank
+      #
+      def validate(setting)
+        if allow_blank?
+          return if setting.value.blank?
+        else
+          setting.errors.add :value, :blank if setting.value.blank?
+        end
+        if validate_with.is_a? Proc
+          validate_with.call(setting)
+        end
+        if selector?
+          setting.errors.add :value, :not_permitted unless selectable?(setting.value)
+        end
+        if integer?
+          Integer(setting.value) rescue setting.errors.add :value, :not_a_number
+        end
+      end
+      
+      # Returns true if the value is one of the permitted selections. Not case-sensitive.
+      def selectable?(value)
+        return true unless selector?
+        selection.map(&:last).map(&:downcase).include?(value.downcase)
+      end
+      
+      # Returns true unless :allow_blank has been explicitly set to false. Defaults to true.
+      # A config item that does not allow_blank must be set or it will not be valid.
+      def allow_blank?
+        true unless allow_blank == false
+      end
+      
+      # Returns true unless :allow_change has been explicitly set to false. Defaults to true. 
+      # A config item that is not settable cannot be changed in the running application.
+      def settable?
+        true unless allow_change == false
+      end
+      
+      # Returns true unless :allow_change has been explicitly set to false. Defaults to true.
+      # A config item that is not visible cannot be displayed in a radius tag.
+      def visible?
+        true unless allow_display == false
+      end
+      
+      # Returns true if :allow_display has been explicitly set to false. Defaults to true.
+      def hidden?
+        true if allow_display == false
+      end
+      
+    end
+  end
+end
+

data/lib/trusty_cms/engine.rb

@@ -0,0 +1,10 @@
+module TrustyCms
+  class Engine < Rails::Engine
+    isolate_namespace TrustyCms
+
+    config.generators do |g|
+      g.test_framework :rspec
+      g.integration_tool :cucumber
+    end
+  end
+end

data/lib/trusty_cms/extension/script.rb

@@ -0,0 +1,395 @@
+require 'active_resource'
+require 'tmpdir'
+require 'fileutils'
+require 'rake'
+
+module Registry
+  class Extension < ActiveResource::Base
+    self.site = ENV['REGISTRY_URL'] || "http://ext.radiantcms.org/"
+
+    def install
+      Registry.const_get(install_type).new(self).install
+    end
+
+    def uninstall
+      Uninstaller.new(self).uninstall
+    end
+
+    def inspect
+%{
+Name:           #{name}
+Description:
+  #{description}
+Author:         #{author.name} <#{author.email}>
+Source code:    #{repository_url}
+Download:       #{download_url}
+Install type:   #{install_type}
+Supports:       TrustyCms #{supports_radiant_version}
+}.strip
+    end
+  end
+
+  class Action
+    def rake(command)
+      puts "rake #{command}"
+      puts `rake #{command} Rails.env=#{Rails.env}` if tasks_include? command
+    end
+
+    def tasks_include?(command)
+      command = command.split(':')
+      if command.length > 1 && command[0..1] == ['radiant','extensions']
+        extension = command[2]
+        task = "radiant:extensions:#{extension}:#{command[3].split[0]}"
+      else
+        extension = task = command[0]
+      end
+      rake_file = File.join(Rails.root, 'vendor', 'extensions', extension) + '/lib/tasks/' + extension + '_extension_tasks.rake'
+      load rake_file if File.exist? rake_file
+      tasks = Rake.application.tasks.map(&:name)
+      tasks.include? task
+    end
+    
+    def file_utils
+      FileUtils
+    end
+    
+    delegate :cd, :cp_r, :rm_r, :to => :file_utils
+  end
+
+  class Installer < Action
+    attr_accessor :url, :path, :name
+    def initialize(url, name)
+      self.url, self.name = url, name
+    end
+
+    def install
+      copy_to_vendor_extensions
+      migrate
+      update
+    end
+
+    def copy_to_vendor_extensions
+      cp_r(self.path, File.expand_path(File.join(Rails.root, 'vendor', 'extensions', name)))
+      rm_r(self.path)
+    end
+
+    def migrate
+      rake "radiant:extensions:#{name}:migrate"
+    end
+
+    def update
+      rake "radiant:extensions:#{name}:update"
+    end
+  end
+
+  class Uninstaller < Action
+    attr_accessor :name
+    def initialize(extension)
+      self.name = extension.name
+    end
+
+    def uninstall
+      migrate_down
+      remove_extension_directory
+    end
+
+    def migrate_down
+      rake "radiant:extensions:#{name}:migrate VERSION=0"
+    end
+
+    def remove_extension_directory
+      rm_r(File.join(Rails.root, 'vendor', 'extensions', name))
+    end
+  end
+
+  class Checkout < Installer
+    def initialize(extension)
+      super(extension.repository_url, extension.name)
+    end
+
+    def checkout_command
+      raise "Not Implemented!"
+    end
+
+    def install
+      checkout
+      super
+    end
+
+    def checkout
+      self.path = File.join(Dir.tmpdir, name)
+      cd(Dir.tmpdir) { system "#{checkout_command}" }
+    end
+  end
+
+  class Download < Installer
+    def initialize(extension)
+      super(extension.download_url, extension.name)
+    end
+
+    def install
+      download
+      unpack
+      super
+    end
+
+    def unpack
+      raise "Not Implemented!"
+    end
+
+    def filename
+      File.basename(self.url)
+    end
+
+    def download
+      require 'open-uri'
+      File.open(File.join(Dir.tmpdir, self.filename), 'w') {|f| f.write open(self.url).read }
+    end
+  end
+
+  class Git < Checkout
+    def project_in_git?
+      @in_git ||= File.directory?(".git")
+    end
+    
+    def checkout_command
+      "git clone #{url} #{name}"
+    end
+    
+    def checkout
+      if project_in_git?
+        system "git submodule add #{url} vendor/extensions/#{name}"
+        cd(File.join('vendor', 'extensions', name)) do
+          system "git submodule init && git submodule update"
+        end
+      else
+        super
+        cd(path) do
+          system "git submodule init && git submodule update"
+        end
+      end
+    end
+    
+    def copy_to_vendor_extensions
+      super unless project_in_git?
+    end
+  end
+
+  class Subversion < Checkout
+    def checkout_command
+      "svn checkout #{url} #{name}"
+    end
+  end
+
+  class Gem < Download
+    def gem_name(name)
+      name.gsub(/-\d+\.\d+\.\d+(.+)?\.gem/, '')
+    end
+
+    def download
+      # Don't download the gem if it's already installed
+      extension = gem_name(filename)
+      begin
+        gem extension
+      rescue ::Gem::LoadError
+        super
+        `gem install #{extension}`
+      end
+    end
+
+    def unpack
+      output = nil
+      cd(Dir.tmpdir) do
+        output = `gem unpack #{gem_name(filename)}`
+      end
+      self.path = output.match(/'(.*)'/)[1]
+    end
+  end
+
+  class Tarball < Download
+    def filename
+      "#{self.name}.tar"
+    end
+
+    def unpack
+      output = nil
+      cd(Dir.tmpdir) { output = `tar xvf #{filename}` }
+      self.path = File.join(Dir.tmpdir, output.split(/\n/).first.split('/').first)
+    end
+  end
+
+  class Gzip < Tarball
+    def filename
+      @unpacked ? super : "#{self.name}.tar.gz"
+    end
+
+    def unpack
+      cd(Dir.tmpdir) { system "gunzip #{self.filename}" }
+      @unpacked = true
+      super
+    end
+  end
+
+  class Bzip2 < Tarball
+    def filename
+      @unpacked ? super : "#{self.name}.tar.bz2"
+    end
+
+    def unpack
+      cd(Dir.tmpdir) { system "bunzip2 #{self.filename}" }
+      @unpacked = true
+      super
+    end
+  end
+
+  class Zip < Download
+    def unpack
+      output = nil
+      cd(Dir.tmpdir) { output = `unzip #{filename} -d #{name}` }
+      self.path = File.join(Dir.tmpdir, name)
+    end
+  end
+end
+
+module TrustyCms
+  class Extension
+    module Script
+      class << self
+        def execute(args)
+          command = args.shift || 'help'
+          begin
+            const_get(command.camelize).new(args)
+          rescue ArgumentError => e
+            puts e.message
+            Help.new [command]
+          end
+        end
+      end
+
+      module Util
+        attr_accessor :extension_name, :extension
+
+        def to_extension_name(string)
+          string.to_s.underscore
+        end
+
+        def installed?
+          path_match = Regexp.compile("(^|/|\\\\)#{extension_name}$")
+          extension_paths.any? {|p| p =~ path_match }
+        end
+
+        def registered?
+          self.extension
+        end
+
+        def extension_paths
+          paths = [Rails.root, TRUSTY_CMS_ROOT].uniq.map { |p| Dir["#{p}/vendor/extensions/*"] }
+          paths.unshift Dir["#{TRUSTY_CMS_ROOT}/test/fixtures/extensions/*"] if Rails.env == 'test'    #nasty
+          paths.flatten
+        end
+
+        def load_extensions
+          Registry::Extension.find(:all)
+        end
+
+        def find_extension
+          self.extension = load_extensions.find{|e| e.name == self.extension_name }
+        end
+      end
+
+      class Install
+        include Util
+
+        def initialize(args=[])
+          raise ArgumentError, "You must specify an extension to install." if args.blank?
+          self.extension_name = to_extension_name(args.shift)
+          if installed?
+            puts "#{extension_name} is already installed."
+          else
+            find_extension
+            if registered?
+              extension.install
+            else
+              raise ArgumentError, "#{extension_name} is not available in the registry."
+            end
+          end
+        end
+      end
+
+      class Uninstall
+        include Util
+
+        def initialize(args=[])
+          raise ArgumentError, "You must specify an extension to uninstall." if args.blank?
+          self.extension_name = to_extension_name(args.shift)
+          if installed?
+            find_extension && extension.uninstall
+          else
+            puts "#{extension_name} is not installed."
+          end
+        end
+      end
+
+      class Info
+        include Util
+
+        def initialize(args=[])
+          raise ArgumentError, "You must specify an extension to get info on" if args.blank?
+          self.extension_name = to_extension_name(args.shift)
+          find_extension and puts extension.inspect
+        end
+      end
+
+      class Help
+        def initialize(args=[])
+          command = args.shift
+          command = 'help' unless self.class.instance_methods(false).collect {|im| im.to_s}.include?(command.to_s)
+          send(command)
+        end
+
+        def help
+          $stdout.puts %{Usage:   script/extension command [arguments]
+
+  Available commands:
+      #{command_names}
+
+  For help on an individual command:
+      script/extension help command
+      
+  You may install extensions from another registry by setting the REGISTRY_URL
+  By default the REGISTRY_URL is set to http://ext.radiantcms.org
+  
+  Code for the registry application may be found at:
+  http://github.com/radiant/radiant-extension-registry/
+            }
+        end
+
+        def install
+          $stdout.puts %{Usage:    script/extension install extension_name
+
+  Installs an extension from information in the global registry.
+          }
+        end
+
+        def uninstall
+          $stdout.puts %{Usage:    script/extension uninstall extension_name
+
+  Removes a previously installed extension from the current project.
+            }
+        end
+
+        def info
+          $stdout.puts %{Usage:    script/extension info extension_name
+
+  Displays registry information about the extension.
+          }
+        end
+
+        private
+          def command_names
+            (TrustyCms::Extension::Script.constants - ['Util']).sort.map {|n| n.to_s.underscore }.join(", ")
+          end
+      end
+    end
+  end
+end

data/lib/trusty_cms/extension.rb

@@ -0,0 +1,146 @@
+require 'annotatable'
+require 'simpleton'
+require 'trusty_cms/admin_ui'
+
+module TrustyCms
+  class Extension
+    include Simpleton
+    include Annotatable
+
+    annotate :version, :description, :url, :extension_name, :path
+
+    attr_writer :active
+    
+    def active?
+      @active
+    end
+    
+    def root
+      path.to_s
+    end
+    
+    def migrated?
+      migrator.new(:up, migrations_path).pending_migrations.empty?
+    end
+    
+    def enabled?
+      active? and migrated?
+    end
+    
+    # Conventional plugin-like routing
+    def routed?
+      File.exist?(routing_file)
+    end
+    
+    def migrations_path
+      File.join(self.root, 'db', 'migrate')
+    end
+    
+    def migrates_from
+      @migrates_from ||= {}
+    end
+    
+    def routing_file
+      File.join(self.root, 'config', 'routes.rb')
+    end
+        
+    def load_initializers
+      Dir["#{self.root}/config/initializers/**/*.rb"].sort.each do |initializer|
+        load(initializer)
+      end
+    end
+    
+    def migrator
+      unless @migrator
+        extension = self
+        @migrator = Class.new(ExtensionMigrator){ self.extension = extension }
+      end
+      @migrator
+    end
+    
+    def admin
+      AdminUI.instance
+    end
+    
+    def tab(name, options={}, &block)
+      @the_tab = admin.nav[name]
+      unless @the_tab
+        @the_tab = TrustyCms::AdminUI::NavTab.new(name)
+        before = options.delete(:before)
+        after = options.delete(:after)
+        tab_name = before || after
+        tab_object = admin.nav[tab_name]
+        if tab_object
+          index = admin.nav.index(tab_object)
+          index += 1 unless before
+          admin.nav.insert(index, @the_tab)
+        else
+          admin.nav << @the_tab
+        end
+      end
+      if block_given?
+        block.call(@the_tab)
+      end
+      return @the_tab
+    end
+    alias :add_tab :tab
+    
+    def add_item(*args)
+      @the_tab.add_item(*args)
+    end
+
+    # Determine if another extension is installed and up to date.
+    #
+    # if MyExtension.extension_enabled?(:third_party)
+    #   ThirdPartyExtension.extend(MyExtension::IntegrationPoints)
+    # end
+    def extension_enabled?(extension)
+      begin
+        extension = (extension.to_s.camelcase + 'Extension').constantize
+        extension.enabled?
+      rescue NameError
+        false
+      end
+    end
+
+    class << self
+
+      def activate_extension
+        return if instance.active?
+        instance.activate if instance.respond_to? :activate
+        TrustyCms::Application.config.paths["config/routes"].concat([instance.routing_file]) if instance.routed?
+        TrustyCms::Application.reload_routes!
+        instance.active = true
+      end
+      alias :activate :activate_extension
+
+      def deactivate_extension
+        return unless instance.active?
+        instance.active = false
+        instance.deactivate if instance.respond_to? :deactivate
+      end
+      alias :deactivate :deactivate_extension
+
+      def inherited(subclass)
+        subclass.extension_name = subclass.name.to_name('Extension')
+      end
+
+      def migrate_from(extension_name, until_migration=nil)
+        instance.migrates_from[extension_name] = until_migration
+      end
+
+      # Expose the configuration object for init hooks
+      # class MyExtension < ActiveRecord::Base
+      #   extension_config do |config|
+      #     config.after_initialize do
+      #       run_something
+      #     end
+      #   end
+      # end
+      def extension_config(&block)
+        yield Rails.configuration
+      end
+      
+    end
+  end
+end