refinerycms-core 1.0.11 → 2.0.0

data/lib/refinery/errors.rb

@@ -0,0 +1,13 @@
+module Refinery
+
+  # = Refinery Errors
+  #
+  # Generic Refinery exception class
+  class RefineryError < StandardError
+  end
+
+  # Raised when an extension has not been properly defined. See the exception message for further
+  # details
+  class InvalidEngineError < RefineryError
+  end
+end

data/lib/refinery/ext/action_view/helpers/form_builder.rb

@@ -0,0 +1,7 @@
+ActionView::Helpers::FormBuilder.module_eval do
+
+  def required_label(method, options = {})
+    @template.required_label(@object_name, method, objectify_options(options))
+  end
+
+end

data/lib/refinery/ext/action_view/helpers/form_helper.rb

@@ -0,0 +1,20 @@
+ActionView::Helpers::FormHelper.module_eval do
+
+  def required_label(object_name, method, options = {})
+    options = {:class => "required"}.merge!(options)
+
+    label(object_name, method, "#{label_humanize_text(method, options)} *", options)
+  end
+
+
+  def label_humanize_text method, options = {}
+    object = options[:object]
+
+    content ||= if object && object.class.respond_to?(:human_attribute_name)
+      object.class.human_attribute_name(method)
+    end
+
+    content ||= method.humanize
+  end
+
+end

data/lib/refinery/ext/action_view/helpers/form_tag_helper.rb

@@ -0,0 +1,10 @@
+ActionView::Helpers::FormTagHelper.module_eval do
+
+  def required_label_tag(name, text = nil, options = {})
+    options = {:class => "required"}.merge!(options)
+    text ||= "#{name.to_s.humanize} *"
+
+    label_tag(name, text, options)
+  end
+
+end

data/lib/refinery/extension_generation.rb

@@ -0,0 +1,258 @@
+module Refinery
+  module ExtensionGeneration
+
+    def self.included(base)
+      base.class_eval do
+        argument :attributes, :type => :array, :default => [], :banner => "field:type field:type"
+
+        class_option :namespace, :type => :string, :default => nil, :banner => 'NAMESPACE', :required => false
+        class_option :extension, :type => :string, :default => nil, :banner => 'ENGINE', :required => false
+        class_option :i18n, :type => :array, :default => [], :required => false, :banner => "field field", :desc => 'Indicates generated fields'
+
+        remove_class_option :skip_namespace
+
+        def namespacing
+          @namespacing ||= if options[:namespace].present?
+            # Use exactly what the user requested, not a pluralised version.
+            options[:namespace].to_s.camelize
+          else
+            class_name.pluralize
+          end
+        end
+
+        def extension_name
+          @extension_name ||= if options[:extension].present?
+            # Use exactly what the user requested, not a made up version.
+            options[:extension].to_s
+          else
+            singular_name
+          end
+        end
+
+        def extension_class_name
+          @extension_class_name ||= extension_name.camelize
+        end
+
+        def extension_plural_class_name
+          @extension_plural_class_name ||= if options[:extension].present?
+            # Use exactly what the user requested, not a plural version.
+            extension_class_name
+          else
+            extension_class_name.pluralize
+          end
+        end
+
+        def extension_plural_name
+          @extension_plural_name ||= if options[:extension].present?
+            # Use exactly what the user requested, not a plural version.
+            extension_name
+          else
+            extension_name.pluralize
+          end
+        end
+
+        def localized?
+          localized_attributes.any?
+        end
+
+        def localized_attributes
+          @localized_attributes ||= attributes.select{|a| options[:i18n].include?(a.name)}
+        end
+
+        def attributes_for_translation_table
+          localized_attributes.inject([]) {|memo, attr| memo << ":#{attr.name} => :#{attr.type}"}.join(', ')
+        end
+
+      protected
+
+        def append_extension_to_gemfile!
+          unless Rails.env.test? || (self.behavior != :revoke && extension_in_gemfile?)
+            path = extension_pathname.parent.relative_path_from(gemfile.parent)
+            append_file gemfile, "\ngem '#{gem_name}', :path => '#{path}'"
+          end
+        end
+
+        def clash_keywords
+          @clash_keywords ||= begin
+            clash_keywords = []
+            unless (clash_file = source_pathname.parent.join('clash_keywords.yml')).file?
+              clash_file = source_pathname.parent.parent.join('clash_keywords.yml')
+            end
+            clash_keywords = YAML.load_file(clash_file) if clash_file.file?
+            clash_keywords
+          end
+        end
+
+        def destination_pathname
+          @destination_pathname ||= Pathname.new(self.destination_root.to_s)
+        end
+
+        def extension_pathname
+          destination_pathname.join('vendor', 'extensions', extension_plural_name)
+        end
+
+        def extension_path_for(path, extension)
+          path = extension_pathname.join(path.to_s.gsub(%r{#{source_pathname}/?}, '')).to_s
+
+          path.gsub!('extension_plural_name', extension_plural_name)
+          path.gsub!('plural_name', plural_name)
+          path.gsub!('singular_name', singular_name)
+          path.gsub!('namespace', namespacing.underscore)
+
+          if options[:namespace].present? || options[:extension].present?
+            # Increment the migration file leading number
+            # Only relevant for nested or namespaced extensions, where a previous migration exists
+            if path =~ %r{/migrate/\d+\w*.rb\z}
+              if last_migration = Dir["#{destination_pathname.join(path.split(File::SEPARATOR)[0..-2].join(File::SEPARATOR), '*.rb')}"].sort.last
+                path.gsub!(%r{\d+_}) { |m| "#{last_migration.match(%r{migrate/(\d+)_})[1].to_i + 1}_" }
+              end
+            end
+
+            # Detect whether this is a special file that needs to get merged not overwritten.
+            # This is important only when nesting extensions.
+            if extension.present? && File.exist?(path)
+              path = if path =~ %r{/locales/.*\.yml$} or path =~ %r{/routes.rb$} or path =~ %r{/#{gem_name}.rb$}
+                # put new translations into a tmp directory
+                path.split(File::SEPARATOR).insert(-2, "tmp").join(File::SEPARATOR)
+              elsif path =~ %r{/readme.md$} or path =~ %r{/#{plural_name}.rb$}
+                nil
+              else
+                path
+              end
+            elsif extension.present? and path =~ /lib\/#{plural_name}.rb$/
+              path = nil
+            end
+          end
+
+          path
+        end
+
+        def erase_destination!
+          if Pathname.glob(extension_pathname.join('**', '*')).all?(&:directory?)
+            say_status :remove, relative_to_original_destination_root(extension_pathname.to_s), true
+            FileUtils.rm_rf extension_pathname unless options[:pretend]
+          end
+        end
+
+        def evaluate_templates!
+          Pathname.glob(source_pathname.join('**', '**')).reject{|f|
+            reject_template?(f)
+          }.sort.each do |path|
+            if (template_path = extension_path_for(path, extension_name)).present?
+              template path, template_path
+            end
+          end
+        end
+
+        def existing_extension?
+          options[:extension].present? && extension_pathname.directory? && extension_in_gemfile?
+        end
+
+        def exit_with_message!(message)
+          puts ""
+          puts message
+          puts ""
+          exit(1)
+        end
+
+        def extension_in_gemfile?
+          gemfile.read.scan(%r{#{gem_name}}).any?
+        end
+
+        def finalize_extension!
+          if self.behavior != :revoke and !self.options['pretend']
+            puts_instructions!
+          else
+            erase_destination!
+          end
+        end
+
+        def gem_name
+          "refinerycms-#{extension_plural_name}"
+        end
+
+        def gemfile
+          @gemfile ||= begin
+            Bundler.default_gemfile || destination_pathname.join('Gemfile')
+          end
+        end
+
+        def merge_locales!
+          if existing_extension?
+            # go through all of the temporary files and merge what we need into the current files.
+            tmp_directories = []
+            Dir.glob(source_pathname.join("{config/locales/*.yml,config/routes.rb,lib/refinerycms-extension_plural_name.rb}"), File::FNM_DOTMATCH).sort.each do |path|
+              # get the path to the current tmp file.
+              new_file_path = destination_pathname.join(extension_path_for(path, extension_name))
+              tmp_directories << Pathname.new(new_file_path.to_s.split(File::SEPARATOR)[0..-2].join(File::SEPARATOR)) # save for later
+              # get the path to the existing file and perform a deep hash merge.
+              current_path = Pathname.new(new_file_path.to_s.split(File::SEPARATOR).reject{|f| f == 'tmp'}.join(File::SEPARATOR))
+              new_contents = nil
+              if new_file_path.to_s =~ %r{.yml$}
+                # merge translation files together.
+                new_contents = YAML::load(new_file_path.read).deep_merge(YAML::load(current_path.read)).to_yaml.gsub(%r{^---\n}, '')
+              elsif new_file_path.to_s =~ %r{/routes.rb$}
+                # append any routes from the new file to the current one.
+                routes_file = [(file_parts = current_path.read.to_s.split("\n")).first]
+                routes_file += file_parts[1..-2]
+                routes_file += new_file_path.read.to_s.split("\n")[1..-2]
+                routes_file << file_parts.last
+                new_contents = routes_file.join("\n")
+              elsif new_file_path.to_s =~ %r{/#{gem_name}.rb$}
+                new_contents = current_path.read + new_file_path.read
+              end
+              # write to current file the merged results.
+              current_path.open('w+') { |file| file.puts new_contents } if new_contents
+            end
+
+            tmp_directories.uniq.each{|dir| remove_dir(dir) if dir && dir.exist?}
+          end
+        end
+
+        def puts_instructions!
+          unless Rails.env.test?
+            puts "------------------------"
+            puts "Now run:"
+            puts "bundle install"
+            puts "rails generate refinery:#{extension_plural_name}"
+            puts "rake db:migrate"
+            puts "rake db:seed"
+            puts "------------------------"
+          end
+        end
+
+        def reject_file?(file)
+          !localized? && file.to_s.include?('locale_picker')
+        end
+
+        def reject_template?(file)
+          file.directory? || reject_file?(file)
+        end
+
+        def sanity_check!
+          if clash_keywords.member?(singular_name.downcase)
+            exit_with_message!("Please choose a different name. The generated code would fail for class '#{singular_name}' as it conflicts with a reserved keyword.")
+          end
+
+          if singular_name == plural_name
+            message = if singular_name.singularize == singular_name
+              "The extension name you specified will not work as the singular name is equal to the plural name."
+            else
+              "Please specify the singular name '#{singular_name.singularize}' instead of '#{plural_name}'."
+            end
+            exit_with_message!(message)
+          end
+
+          if attributes.empty? && self.behavior != :revoke
+            exit_with_message!("You must specify a name and at least one field. For help: #{generator_command}")
+          end
+        end
+
+        def source_pathname
+          @source_pathname ||= Pathname.new(self.class.source_root.to_s)
+        end
+      end
+    end
+
+  end
+end

data/lib/refinery/menu.rb

@@ -44,24 +44,5 @@ module Refinery
 
     # The delegation is specified so crazily so that it works on 1.8.x and 1.9.x
     delegate *((Array.instance_methods - Object.instance_methods) << {:to => :items})
-
-    # Ensure that things still work from how the menu partials worked before.
-    def live
-      Refinery.deprecate({
-        :what => "'live' on a ::Refinery::Menu instance",
-        :when => '1.1 with no replacement'
-      })
-
-      self
-    end
-
-    def in_menu
-      Refinery.deprecate({
-        :what => "'in_menu' on a ::Refinery::Menu instance",
-        :when => '1.1 with no replacement'
-      })
-
-      self
-    end
   end
 end

data/lib/refinery/menu_item.rb

@@ -1,18 +1,37 @@
 module Refinery
   class MenuItem < HashWithIndifferentAccess
 
-    (ATTRIBUTES = [:id, :title, :parent_id, :lft, :rgt, :depth, :url, :menu_id, :menu_match, :type]).each do |attribute|
-      class_eval %{
-        def #{attribute}
-          @#{attribute} ||= self[:#{attribute}]
-        end
+    class << self
+      def attributes
+        [:title, :parent_id, :lft, :rgt, :depth, :url, :menu_id, :menu_match]
+      end
 
-        def #{attribute}=(attr)
-          @#{attribute} = attr
+      def apply_attributes!
+        attributes.each do |attribute|
+          class_eval %{
+            def #{attribute}
+              @#{attribute} ||= self[:#{attribute}]
+            end
+          } unless self.respond_to?(attribute)
+          class_eval %{
+            def #{attribute}=(attr)
+              @#{attribute} = attr
+            end
+          } unless self.respond_to?(:"#{attribute}=")
         end
-      }
+      end
+    end
+
+    def original_id
+      @original_id ||= self[:id]
     end
 
+    def original_type
+      @original_type ||= self[:type]
+    end
+
+    apply_attributes!
+
     def ancestors
       return @ancestors if @ancestors
       @ancestors = []
@@ -24,7 +43,7 @@ module Refinery
 
     def children
       @children ||= if has_children?
-        menu.select{|item| item.type == type && item.parent_id == id}
+        menu.select { |item| item.original_type == original_type && item.parent_id == original_id }
       else
         []
       end
@@ -32,7 +51,7 @@ module Refinery
 
     def descendants
       @descendants ||= if has_descendants?
-        menu.select{|item| item.type == type && item.lft > lft && item.rgt < rgt}
+        menu.select{|item| item.original_type == original_type && item.lft > lft && item.rgt < rgt}
       else
         []
       end
@@ -51,11 +70,11 @@ module Refinery
     def inspect
       hash = {}
 
-      ATTRIBUTES.each do |attribute|
+      self.class.attributes.each do |attribute|
         hash[attribute] = self[attribute]
       end
 
-      hash
+      hash.inspect
     end
 
     def menu
@@ -63,13 +82,12 @@ module Refinery
     end
 
     def parent
-      @parent ||= (menu.detect{|item| item.type == type && item.id == parent_id} if has_parent?)
+      @parent ||= (menu.detect{|item| item.original_type == original_type && item.original_id == parent_id} if has_parent?)
     end
 
     def siblings
       @siblings ||= ((has_parent? ? parent.children : menu.roots) - [self])
     end
     alias_method :shown_siblings, :siblings
-
   end
 end

data/lib/refinery/plugin.rb

@@ -4,47 +4,32 @@ module Refinery
   class Plugin
 
     attr_accessor :name, :class_name, :controller, :directory, :url,
-                  :version, :dashboard, :always_allow_access,
-                  :menu_match, :hide_from_menu,
-                  :pathname, :plugin_activity
-    attr_reader   :description
+                  :version, :dashboard, :always_allow_access, :menu_match,
+                  :hide_from_menu, :pathname, :plugin_activity
 
     def self.register(&block)
       yield(plugin = self.new)
 
       raise "A plugin MUST have a name!: #{plugin.inspect}" if plugin.name.blank?
 
-      # Set the root as Rails::Engine.called_from will always be
-      #                 vendor/engines/refinery/lib/refinery
-      new_called_from = begin
-        # Remove the line number from backtraces making sure we don't leave anything behind
-        call_stack = caller.map { |p| p.split(':')[0..-2].join(':') }
-        File.dirname(call_stack.detect { |p| p !~ %r[railties[\w\-\.]*/lib/rails|rack[\w\-\.]*/lib/rack] })
-      end
-
-      klass = Class.new(Rails::Engine)
-      klass.class_eval <<-RUBY
-        def self.called_from; "#{new_called_from}"; end
-      RUBY
-      Object.const_set(plugin.class_name.to_sym, klass)
+      # Set defaults.
+      plugin.menu_match ||= %r{refinery/#{plugin.name}(/.+?)?$}
+      plugin.always_allow_access ||= false
+      plugin.dashboard ||= false
+      plugin.class_name ||= plugin.name.camelize
 
       # add the new plugin to the collection of registered plugins
       ::Refinery::Plugins.registered << plugin
     end
 
-    # Returns the class name of the plugin
-    def class_name
-      @class_name ||= name.camelize
-    end
-
     # Returns the internationalized version of the title
     def title
-      ::I18n.translate(['plugins', name, 'title'].join('.'))
+      ::I18n.translate(['refinery', 'plugins', name, 'title'].join('.'))
     end
 
     # Returns the internationalized version of the description
     def description
-      ::I18n.translate(['plugins', name, 'description'].join('.'))
+      ::I18n.translate(['refinery', 'plugins', name, 'description'].join('.'))
     end
 
     # Retrieve information about how to access the latest activities of this plugin.
@@ -57,24 +42,14 @@ module Refinery
       [activities].flatten.each { |activity| add_activity(activity) }
     end
 
-    # Returns true, if the user doesn't require plugin access
-    def always_allow_access?
-      @always_allow_access ||= false
-    end
-
-    # Special property to indicate that this plugin is the dashboard plugin.
-    def dashboard?
-      @dashboard ||= false
+    # Given a record's class name, find the related activity object.
+    def activity_by_class_name(class_name)
+      self.activity.select{ |a| a.class_name == class_name.to_s.camelize }
     end
 
     # Used to highlight the current tab in the admin interface
     def highlighted?(params)
-      (params[:controller] =~ self.menu_match) or (self.dashboard? and params[:action] == 'error_404')
-    end
-
-    # Returns a RegExp that matches, if the current page is part of the plugin.
-    def menu_match
-      @menu_match ||= /(admin|refinery)\/#{self.name}$/
+      !!(params[:controller].try(:gsub, "admin/", "") =~ menu_match) || (dashboard && params[:action] == 'error_404')
     end
 
     def pathname=(value)
@@ -84,13 +59,14 @@ module Refinery
 
     # Returns a hash that can be used to create a url that points to the administration part of the plugin.
     def url
-      @url ||= if self.controller.present?
-        {:controller => "/admin/#{self.controller}"}
-      elsif self.directory.present?
-        {:controller => "/admin/#{self.directory.split('/').pop}"}
+      @url ||= if controller.present?
+        { :controller => "refinery/admin/#{controller}" }
+      elsif directory.present?
+        { :controller => "refinery/admin/#{directory.split('/').pop}" }
       else
-        {:controller => "/admin/#{self.name}"}
+        { :controller => "refinery/admin/#{name}" }
       end
+      @url.is_a?(Hash) ? {:only_path => true}.merge(@url) : @url
     end
 
   # Make this protected, so that only Plugin.register can use it.

data/lib/refinery/plugins.rb

@@ -3,7 +3,7 @@ module Refinery
 
     def find_by_model(model)
       model = model.constantize if model.is_a? String
-      detect { |plugin| plugin.activity.any? {|activity| activity.class == model } }
+      detect { |plugin| plugin.activity.any? {|activity| activity.klass == model } }
     end
 
     def find_by_name(name)
@@ -37,7 +37,7 @@ module Refinery
       end
 
       def always_allowed
-        new registered.select(&:always_allow_access?)
+        new registered.select(&:always_allow_access)
       end
 
       def registered

data/lib/refinery/version.rb

@@ -0,0 +1,16 @@
+module Refinery
+  class Version
+    @major = 2
+    @minor = 0
+    @tiny  = 0
+    @build = nil
+
+    class << self
+      attr_reader :major, :minor, :tiny, :build
+
+      def to_s
+        [@major, @minor, @tiny, @build].compact.join('.')
+      end
+    end
+  end
+end