refinerycms-core 2.0.10 → 2.1.0

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

@@ -1,3 +1,5 @@
+require 'action_view/helpers'
+
 ActionView::Helpers::FormBuilder.module_eval do
 
   def required_label(method, options = {})

data/lib/refinery/extension_generation.rb

@@ -8,6 +8,7 @@ module Refinery
         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'
+        class_option :install, :type => :boolean, :default => false, :required => false, :banner => nil, :desc => 'Bundles and runs the generated generator, rake db:migrate, rake db:seed for you'
 
         remove_class_option :skip_namespace
       end
@@ -18,7 +19,13 @@ module Refinery
         # Use exactly what the user requested, not a pluralised version.
         options[:namespace].to_s.camelize
       else
-        class_name.pluralize
+        # If the user has passed an engine, we want to generate it inside of
+        # that extension.
+        if options[:extension].present?
+          options[:extension].to_s.camelize
+        else
+          class_name.pluralize
+        end
       end
     end
 
@@ -83,7 +90,7 @@ module Refinery
       end
     end
 
-  protected
+    protected
 
     def append_extension_to_gemfile!
       unless Rails.env.test? || (self.behavior != :revoke && extension_in_gemfile?)
@@ -103,6 +110,24 @@ module Refinery
       end
     end
 
+    def default_generate!
+      sanity_check!
+
+      evaluate_templates!
+
+      unless options[:pretend]
+        merge_existing_files! if existing_extension?
+
+        copy_or_merge_seeds!
+
+        append_extension_to_gemfile!
+      end
+
+      install! if options[:install]
+
+      finalize_extension!
+    end
+
     def destination_pathname
       @destination_pathname ||= Pathname.new(self.destination_root.to_s)
     end
@@ -112,44 +137,20 @@ module Refinery
     end
 
     def extension_path_for(path, extension, apply_tmp = true)
-      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)
+      path = extension_pathname.join path.sub(%r{#{source_pathname}/?}, '')
+      path = substitute_path_placeholders path
 
       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 %r{/migrate/\d+.*\.rb.erb\z} === path
-          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
+        path = increment_migration_timestamp(path)
 
         # Detect whether this is a special file that needs to get merged not overwritten.
         # This is important only when nesting extensions.
         # Routes and #{gem_name}\.rb have an .erb extension as path points to the generator template
         # We have to exclude it when checking if the file already exists and  include it in the regexps
-        if extension.present? && File.exist?(path.gsub(/\.erb$/, ""))
-          if %r{/locales/.*\.yml$} === path ||
-             %r{/routes\.rb\.erb$} === path ||
-             %r{/#{gem_name}\.rb\.erb$} === path
-            # put new translations into a tmp directory
-            if apply_tmp
-              path = path.split(File::SEPARATOR).insert(-2, "tmp").
-                          join(File::SEPARATOR)
-            end
-          elsif %r{/readme.md$} === path || %r{/#{plural_name}.rb$} === path
-            path = nil
-          end
-        elsif extension.present? and path =~ /lib\/#{plural_name}.rb$/
-          path = nil
-        end
+        path = extension_path_for_nested_extension(path, apply_tmp) if extension.present?
       end
 
-      path.present? ? Pathname.new(path) : path
+      path
     end
 
     def erase_destination!
@@ -160,18 +161,12 @@ module Refinery
     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?
-          next if path.to_s =~ /seeds.rb.erb/
-
-          unless path.to_s =~ /views/
-            template_path = template_path.to_s.sub(".erb", "")
-          end
+      viable_templates.each do |source_path, destination_path|
+        next if /seeds.rb.erb/ === source_path.to_s
 
-          template path, template_path
-        end
+        destination_path.sub!('.erb', '') if source_path.to_s !~ /views/
+
+        template source_path, destination_path
       end
     end
 
@@ -189,8 +184,8 @@ module Refinery
     end
 
     def finalize_extension!
-      if self.behavior != :revoke and !self.options['pretend']
-        puts_instructions!
+      if self.behavior != :revoke && !self.options['pretend']
+        instruct_user!
       else
         erase_destination!
       end
@@ -210,79 +205,47 @@ module Refinery
       raise "You must override the method 'generator_command' in your generator."
     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.erb,lib/refinerycms-extension_plural_name.rb.erb}"), File::FNM_DOTMATCH).sort.each do |path|
-          # get the path to the current tmp file.
-          # Both the new and current paths need to strip the .erb portion from the generator template
-          new_file_path = Pathname.new extension_path_for(path, extension_name).to_s.gsub(/\.erb$/, "")
-          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 extension_path_for(path, extension_name, false).to_s.gsub(/\.erb$/, "")
-          new_contents = nil
-
-          if File.exist?(new_file_path) && %r{.yml$} === new_file_path.to_s
-            # 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 %r{/routes.rb$} === new_file_path.to_s
-            # 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 %r{/#{gem_name}.rb$} === new_file_path.to_s
-            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
+    def install!
+      run "bundle install"
+      run "rails generate refinery:#{extension_plural_name}"
+      run "rake db:migrate"
+      run "rake db:seed"
+    end
 
-        tmp_directories.uniq.each{|dir| remove_dir(dir) if dir && dir.exist?}
+    def merge_existing_files!
+      # go through all of the temporary files and merge what we need into the current files.
+      tmp_directories = []
+      globs = %w[config/locales/*.yml config/routes.rb.erb lib/refinerycms-extension_plural_name.rb.erb]
+      Pathname.glob(source_pathname.join("{#{globs.join(',')}}"), File::FNM_DOTMATCH).each do |path|
+        # get the path to the current tmp file.
+        # Both the new and current paths need to strip the .erb portion from the generator template
+        new_file_path = extension_path_for(path, extension_name).sub(/\.erb$/, '')
+        tmp_directories << new_file_path.split.first
+        current_path = extension_path_for(path, extension_name, false).sub(/\.erb$/, '')
+
+        FileMerger.new(self, current_path, new_file_path, :to => current_path, :mode => 'w+').call
       end
+
+      tmp_directories.uniq.each(&:rmtree)
     end
 
     def copy_or_merge_seeds!
-      source_seed_file      = source_pathname.join("db/seeds.rb.erb")
-      destination_seed_file = destination_pathname.join(
-        extension_path_for(
-          source_seed_file.to_s.sub(".erb", ""), extension_name
-        )
-      )
-
-      if existing_extension?
-        # create temp seeds file
-        temp_seed_file = destination_pathname.join(
-          extension_path_for("tmp/seeds.rb", extension_name)
-        )
-
-        # copy/evaluate seeds template to temp file
-        template source_seed_file, temp_seed_file, :verbose => false
-
-        # append temp seeds file content to extension seeds file
-        destination_seed_file.open('a+') { |file|
-          file.puts temp_seed_file.read.to_s
-        }
-
-        # remove temp file
-        FileUtils.rm_rf temp_seed_file
-      else
-        template source_seed_file, destination_seed_file
-      end
+      FileMerger.new(self, source_seed_file, destination_seed_file).call
     end
 
-    def puts_instructions!
+    def instruct_user!
       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"
+        if options[:install]
+          puts "Your extension has been generated and installed."
+        else
+          puts "Now run:"
+          puts "bundle install"
+          puts "rails generate refinery:#{extension_plural_name}"
+          puts "rake db:migrate"
+          puts "rake db:seed"
+        end
+        puts "Please restart your rails server."
         puts "------------------------"
       end
     end
@@ -296,10 +259,47 @@ module Refinery
     end
 
     def sanity_check!
+      prevent_clashes!
+      prevent_uncountability!
+      prevent_empty_attributes!
+      prevent_invalid_extension!
+    end
+
+    def source_pathname
+      @source_pathname ||= Pathname.new(self.class.source_root.to_s)
+    end
+
+    private
+    def extension_path_for_nested_extension(path, apply_tmp)
+      return nil if !path.sub(/\.erb$/, '').file? &&
+                    %r{readme.md|(lib/)?#{plural_name}.rb$} === path.to_s
+
+      if apply_tmp && %r{(locales/.*\.yml)|((config/routes|#{gem_name})\.rb\.erb)$} === path.to_s
+        path = path.dirname + 'tmp' + path.basename
+      end
+
+      path
+    end
+
+    def increment_migration_timestamp(path)
+      # Increment the migration file leading number
+      # Only relevant for nested or namespaced extensions, where a previous migration exists
+      return path unless %r{/migrate/\d+.*\.rb.erb\z} === path.to_s && last_migration_file(path)
+
+      path.sub(%r{\d+_}) { |m| "#{last_migration_file(path).match(%r{migrate/(\d+)_})[1].to_i + 1}_" }
+    end
+
+    def last_migration_file(path)
+      Dir[destination_pathname.join(path.dirname + '*.rb')].sort.last
+    end
+
+    def prevent_clashes!
       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
+    end
 
+    def prevent_uncountability!
       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."
@@ -308,21 +308,119 @@ module Refinery
         end
         exit_with_message! message
       end
+    end
 
+    def prevent_empty_attributes!
       if attributes.empty? && self.behavior != :revoke
         exit_with_message! "You must specify a name and at least one field." \
                            "\nFor help, run: #{generator_command}"
       end
+    end
 
+    def prevent_invalid_extension!
       if options[:extension].present? && !extension_pathname.directory?
         exit_with_message! "You can't use '--extension #{options[:extension]}' option because" \
                            " extension with name #{options[:extension]} doesn't exist."
       end
     end
 
-    def source_pathname
-      @source_pathname ||= Pathname.new(self.class.source_root.to_s)
+    def source_seed_file
+      source_pathname.join 'db', 'seeds.rb.erb'
+    end
+
+    def destination_seed_file
+      destination_pathname.join extension_path_for(source_seed_file.sub('.erb', ''), extension_name)
+    end
+
+    def substitute_path_placeholders(path)
+      Pathname.new path.to_s.gsub('extension_plural_name', extension_plural_name).
+                             gsub('plural_name', plural_name).
+                             gsub('singular_name', singular_name).
+                             gsub('namespace', namespacing.underscore)
+    end
+
+    def viable_templates
+      @viable_templates ||= begin
+        all_templates.reject(&method(:reject_template?)).inject({}) do |hash, path|
+          if (destination_path = extension_path_for(path, extension_name)).present?
+            hash[path.to_s] = destination_path.to_s
+          end
+
+          hash
+        end
+      end
+    end
+
+    def all_templates
+      Pathname.glob source_pathname.join('**', '**')
+    end
+
+    class FileMerger
+      def initialize(templater, source, destination, options = {})
+        @templater = templater
+        @source = source
+        @destination = destination
+        @options = {:to => @destination, :mode => 'a+'}.merge(options)
+      end
+
+      def call
+        if %r{\.erb$} === @source.basename.to_s
+          templated_merge!
+        else
+          merge!
+        end
+      end
+
+      def contents
+        merged_file_contents
+      end
+
+      private
+      def merge!(contents = merged_file_contents)
+        @options[:to].open(@options[:mode]) { |file| file.puts contents }
+      end
+
+      def merged_file_contents
+        case @destination.to_s
+        # merge translation files together.
+        when %r{.yml$} then merge_yaml
+        # append any routes from the new file to the current one.
+        when %r{/routes.rb$} then merge_rb
+        # simply append the file contents
+        else @source.read + @destination.read
+        end
+      end
+
+      def templated_merge!
+        Dir.mktmpdir do |tmp|
+          tmp = Pathname.new(tmp)
+          @templater.template @source, tmp.join(@source.basename), :verbose => false
+          merge! tmp.join(@source.basename).read.to_s
+        end
+      end
+
+      def merge_rb
+        (source_lines[0..-2] + destination_lines[1..-2] + [source_lines.last]).join "\n"
+      end
+
+      def merge_yaml
+        YAML::load(@destination.read).deep_merge(YAML::load(@source.read)).
+                                      to_yaml.gsub(%r{^---\n}, '')
+      end
+
+      def source_lines
+        @source_lines ||= read_lines @source
+      end
+
+      def destination_lines
+        @destination_lines ||= read_lines @destination
+      end
+
+      def read_lines(file)
+        file.read.to_s.split "\n"
+      end
     end
+    private_constant :FileMerger
 
   end
 end

data/lib/refinery/menu.rb

@@ -2,10 +2,14 @@ module Refinery
   class Menu
 
     def initialize(objects = nil)
-      objects.each do |item|
+       append(objects)
+    end
+
+    def append(objects)
+      Array(objects).each do |item|
         item = item.to_refinery_menu_item if item.respond_to?(:to_refinery_menu_item)
-        items << MenuItem.new(item.merge(:menu => self))
-      end if objects
+        items << MenuItem.new(self, item)
+      end
     end
 
     attr_accessor :items
@@ -15,14 +19,19 @@ module Refinery
     end
 
     def roots
-      @roots ||= items.select {|item| item.parent_id.nil?}
+      @roots ||= select {|item| item.orphan? && item.depth == minimum_depth }
     end
 
     def to_s
-      items.map(&:title).join(' ')
+      map(&:title).join(' ')
+    end
+
+    delegate :inspect, :map, :select, :detect, :first, :last, :length, :size, :to => :items
+
+    protected
+    def minimum_depth
+      map(&:depth).min
     end
 
-    # 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})
   end
 end