effective_developer 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f8689f1bc4992384e17f61c4d8c65dc4c9eff7d8
-  data.tar.gz: a0f2a455a5bf32d0284deebbd5761ec246e146e0
+  metadata.gz: 4dba9b31a7c6e5352ab958ac3a0f1927e5531013
+  data.tar.gz: 4f0127dc920f97aaef72cdad34b09aadac2356fc
 SHA512:
-  metadata.gz: 10cc81aa4428dc08fe8c2f94e9e63702d8ee95e7316b3f4ff9a6dd7cffd06a407e6e22f95233b4f292e2e02dc893fa84f1e2c515627741abcb481961c7cde5dc
-  data.tar.gz: 0c6397219c15e4256b563d251c0d53bdb3ce20b1977ebeb719cd67bce70c0b5f99e718431c0aadb6e594d8be60d30a0b102d05509ec60e3a9ff82a27fdd638da
+  metadata.gz: 447cd0b8ed58bb3bdc2557454795d663ec5a491ee76e7bf967f1aaa7dd37e503ff4603be3217332a0bdf44c5bf018dc9e1e31cd52c94c3df2262b1845f73255c
+  data.tar.gz: 3d7dd836c6fe704dc80082cb4479e56443f77417f17603443a2caec606e5ad20f02c7e9bf5449846f46e53bdfa86401566612bbb54328c51636e05b0ee128840

data/README.md

@@ -210,21 +210,43 @@ Override `before_import()` or `after_import()` to run code before or after the i
 
 # Scaffolding
 
-Scaffolding is the fastest way to build a rails app.  Take advantage of scaffolding.
+Scaffolding is the fastest way to build a rails app. The effective scaffolds try to improve on the rails built in ones.
 
+To generate an entire resource (4 different examples):
 
 ```ruby
-rails generate scaffold product name:string  # active_record, test_unit, resource_route, scaffold_controller, haml, test_unit, helper, assets
-rails generate scaffold_controller product  # haml, test_unit, helper,
-rails generate model product  # active_record, test_unit
-rails generate active_record:model product   # test_unit
-rails generate resource_route product
-rails generate test_unit:model product
-rails generate mailer product
-rails generate job product
+rails generate effective:scaffold thing name:string description:text
+
+rails generate effective:scaffold admin/thing name:string description:text
+
+rails generate effective:scaffold thing name:string description:text --actions crud archive
+
+rails generate effective:scaffold admin/thing name:string description:text --actions crud-show unarchive
 ```
 
+Or, read from the existing model, and just generate the controller, route, ability, menu, datatable, views, form (2 different examples):
+
+```ruby
+rails generate effective:scaffold_controller thing
+
+rails generate effective:scaffold_controller admin/thing --actions crud-show
+```
+
+Or call each scaffold one at a time:
+
+```ruby
+rails generate effective:model thing name:string description:text
+rails generate effective:migration thing name:string description:text
+rails generate effective:controller thing # or admin/thing
+rails generate effective:route thing
+rails generate effective:ability thing # CanCanCan
+rails generate effective:menu thing  # If app/views/*namespaces/_navbar.html.haml is present
+rails generate effective:datatable thing
+rails generate effective:views thing
+rails generate effective:form thing
+```
 
+These scaffold generators are still an ongoing work in progress.  There is a lot more inspect the model and do the right thing type functionality to be implemented "soon".
 
 ## License
 

data/app/models/effective/code_writer.rb

@@ -0,0 +1,218 @@
+module Effective
+  class CodeWriter
+
+    attr_reader :lines
+    attr_reader :filename, :indent, :newline
+
+    def initialize(filename, indent: '  '.freeze, newline: "\n".freeze, &block)
+      @filename = filename
+      @indent = indent
+      @newline = newline
+
+      @from = []
+      @to = []
+
+      @lines = File.open(filename).readlines
+
+      block.call(self)
+
+      File.open(filename, 'w') do |file|
+        lines.each { |line| file.write(line) }
+      end
+    end
+
+    # Returns true if the insert happened, nil if no insert
+    def insert_after_last(content, &block)
+      index = last(&block)
+      return nil unless index
+
+      insert(content, index)
+    end
+
+    # Returns true if the insert happened, nil if no insert
+    def insert_before_last(content, &block)
+      index = last(&block)
+      return nil unless index
+
+      insert(content, index-1)
+    end
+
+    def within(content, &block)
+      content ||= 0
+
+      from = content.kind_of?(Integer) ? content : first { |line| line.start_with?(content) && open?(line) }
+      return nil unless from
+
+      from_depth = depth_at(from)
+
+      to = first(from: from) { |line, depth| depth == from_depth && close?(line) }
+      return nil unless to
+
+      @from.push(from); @to.push(to)
+      yield
+      @from.pop; @to.pop
+    end
+
+    def insert(content, index, depth = nil)
+      contents = (content.kind_of?(Array) ? content : content.split(newline)).map { |str| str.strip }
+
+      depth ||= depth_at(index)
+
+      # If the line we're inserting at is a block, fast-forward the end of the block. And add a newline.
+      if open?(index)
+        index = first(from: index) { |line| close?(line) } + 1
+        lines.insert(index, newline)
+      elsif !whitespace?(index) && (open?(contents) || !same?(contents, index))
+        index += 1
+        lines.insert(index, newline)
+      end
+
+      content_depth = 0
+
+      index = index + 1 # Insert after the given line
+
+      contents.each do |content|
+        content_depth -= 1 if close?(content)
+
+        if content == ''
+          lines.insert(index, newline)
+        else
+          lines.insert(index, (indent * (depth + content_depth)) + content + newline)
+        end
+
+        index += 1
+        content_depth += 1 if open?(content)
+      end
+
+      unless whitespace?(index) || close?(index)
+        if block?(contents) || !same?(contents, index)
+          lines.insert(index, newline)
+        end
+      end
+
+      true
+    end
+
+    def insert_raw(content, index, depth = 0)
+      contents = (content.kind_of?(Array) ? content : content.split(newline))
+
+      index = index + 1 # Insert after the given line
+
+      contents.each do |content|
+        if content.strip == ''
+          lines.insert(index, newline)
+        else
+          lines.insert(index, (indent * depth) + content + newline)
+        end
+
+        index += 1
+      end
+    end
+
+    # Iterate over the lines with a depth, and passed the stripped line to the passed block
+    def each_with_depth(&block)
+      depth = 0
+      from_depth = (@from.last ? depth_at(@from.last) : 0)
+
+      Array(lines).each_with_index do |line, index|
+        stripped = line.to_s.strip
+
+        depth -= 1 if close?(stripped)
+
+        block.call(stripped, depth - from_depth, index)
+        depth += 1 if open?(stripped)
+      end
+
+      nil
+    end
+
+    # Returns the index of the first line where the passed block returns true
+    def first(from: @from.last, to: @to.last, &block)
+      each_with_depth do |line, depth, index|
+        next if index < (from || 0)
+        return index if block.call(line, depth, index)
+        break if to == index
+      end
+    end
+    alias_method :find, :first
+
+    # Returns the index of the last line where the passed block returns true
+    def last(from: @from.last, to: @to.last, &block)
+      retval = nil
+
+      each_with_depth do |line, depth, index|
+        next if index < (from || 0)
+        retval = index if block.call(line, depth, index)
+        break if to == index
+      end
+
+      retval
+    end
+
+    # Returns an array of indexes for each line where the passed block returnst rue
+    def all(from: @from.last, to: @to.last, &block)
+      retval = []
+
+      each_with_depth do |line, depth, index|
+        next if index < (from || 0)
+        retval << index if block.call(line, depth, index)
+        break if to == index
+      end
+
+      retval
+    end
+    alias_method :select, :all
+
+    def depth_at(line_index)
+      if filename.end_with?('.haml')
+        return (lines[line_index].length - lines[line_index].lstrip.length) / indent.length
+      end
+
+      depth = 0
+
+      Array(lines).each_with_index do |line, index|
+        depth -= 1 if close?(line)
+        break if line_index == index
+        depth += 1 if open?(line)
+      end
+
+      depth
+    end
+
+    private
+
+    def open?(content)
+      stripped = ss(content)
+
+      [' do'].any? { |end_with| stripped.end_with?(end_with) } ||
+      ['class ', 'module ', 'def ', 'if '].any? { |start_with| stripped.start_with?(start_with) }
+    end
+
+    def close?(content)
+      stripped = ss(content, array_method: :last)
+      stripped.end_with?('end'.freeze) && !stripped.include?('do ')
+    end
+
+    def whitespace?(content)
+      ss(content).length == 0
+    end
+
+    def block?(content)
+      close?(content) || open?(content)
+    end
+
+    # Is the first word in each line the same?
+    def same?(a, b)
+      ss(a).split(' ').first == ss(b).split(' ').first
+    end
+
+    # Stripped string
+    def ss(value, array_method: :first)
+      value = case value
+      when Integer then lines[value]
+      when Array then value.send(array_method)
+      else value
+      end.strip
+    end
+  end
+end

data/lib/effective_developer/version.rb

@@ -1,3 +1,3 @@
 module EffectiveDeveloper
-  VERSION = '0.0.8'.freeze
+  VERSION = '0.0.9'.freeze
 end

data/lib/generators/effective/ability_generator.rb

@@ -0,0 +1,78 @@
+# rails generate effective:ability NAME [action action] [options]
+
+# Adds a route to app/models/ability.rb
+# rails generate effective:ability Thing
+# rails generate effective:ability Thing index edit create
+
+module Effective
+  module Generators
+    class AbilityGenerator < Rails::Generators::NamedBase
+      include Helpers
+
+      source_root File.expand_path(('../' * 4) + 'lib/scaffolds', __FILE__)
+
+      desc 'Creates a CanCanCan ability.'
+
+      argument :actions, type: :array, default: ['crud'], banner: 'action action'
+
+      def invoke_ability
+        say_status :invoke, :ability, :white
+      end
+
+      def create_ability
+        Effective::CodeWriter.new('app/models/ability.rb') do |w|
+          if namespaces.blank?
+            if w.find { |line, depth| depth == 2 && line == ability }
+              say_status :identical, ability, :blue
+            else
+              w.insert_after_last(ability) { |line, depth| depth == 2 && line.start_with?('can ') } ||
+              w.insert_before_last(ability) { |line, depth| depth == 2 && line.start_with?('if') } ||
+              w.insert_before_last(ability) { |line, depth| depth == 2 && line == 'end' }
+
+              say_status :ability, ability
+            end
+          end
+
+          namespaces.each do |namespace|
+            w.within("if user.is?(:#{namespace})") do
+              if w.find { |line, depth| depth == 1 && line == ability }
+                say_status :identical, ability, :blue
+              else
+                w.insert_after_last(ability) { |line, depth| depth == 1 && line.start_with?('can ') } ||
+                w.insert_before_last(ability) { |line, depth| depth == 1 && line == 'end' }
+
+                say_status "#{namespace}_ability", ability
+              end
+            end
+          end
+        end
+      end
+
+      private
+
+      def ability
+        @ability ||= (
+          abilities = []
+
+          if (crud_actions - invoked_actions).present?
+            abilities += (crud_actions & invoked_actions)
+          end
+
+          if (invoked_actions - crud_actions).present?
+            abilities += (invoked_actions - crud_actions)
+          end
+
+          abilities = ['manage'] if abilities.blank? || abilities == (crud_actions - ['show'])
+
+          if abilities.length == 1
+            abilities = ":#{abilities.first}"
+          else
+            abilities = '[' + abilities.map { |action| ':' + action }.join(', ') + ']'
+          end
+
+          "can #{abilities}, #{class_name}"
+        )
+      end
+    end
+  end
+end

data/lib/generators/effective/controller_generator.rb

@@ -1,33 +1,51 @@
 # rails generate effective:controller NAME [action action] [options]
 
+# Generates a controller
+# rails generate effective:controller Thing
+# rails generate effective:controller Thing index edit create
+# rails generate effective:controller Thing index edit create --attributes name:string description:text
+
 module Effective
   module Generators
     class ControllerGenerator < Rails::Generators::NamedBase
       include Helpers
 
-      source_root File.expand_path(('../' * 4) + 'app/scaffolds', __FILE__)
+      source_root File.expand_path(('../' * 4) + 'lib/scaffolds', __FILE__)
 
       desc 'Creates a controller in your app/controllers folder.'
 
       argument :actions, type: :array, default: ['crud'], banner: 'action action'
       class_option :attributes, type: :array, default: [], desc: 'Included permitted params, otherwise read from model'
 
-      attr_accessor :attributes
+      def assign_actions
+        @actions = invoked_actions
+      end
 
-      def initialize(args, *options)
-        if options.kind_of?(Array) && options.second.kind_of?(Hash)
-          self.attributes = options.second.delete(:attributes)
+      def assign_attributes
+        @attributes = (invoked_attributes.presence || klass_attributes).map do |attribute|
+          Rails::Generators::GeneratedAttribute.parse(attribute)
         end
 
-        super
+        self.class.send(:attr_reader, :attributes)
       end
 
-      def assign_actions
-        @actions = invoked_actions
+      def invoke_controller
+        say_status :invoke, :controller, :white
       end
 
       def create_controller
-        template 'controllers/controller.rb', File.join('app/controllers', class_path, "#{file_name}_controller.rb")
+        template 'controllers/controller.rb', File.join('app/controllers', namespace_path, "#{plural_name}_controller.rb")
+      end
+
+      protected
+
+      def permitted_param_for(attribute_name)
+        case attribute_name
+        when 'roles'
+          'roles: EffectiveRoles.permitted_params'
+        else
+          ':' + attribute_name
+        end
       end
 
     end

data/lib/generators/effective/datatable_generator.rb

@@ -1,18 +1,36 @@
 # rails generate effective:datatable NAME [field[:type] field[:type]] [options]
 
+# TODO
+
+# Generates a datatable
+# rails generate effective:datatable Thing
+# rails generate effective:controller Thing name:string description:text
+
 module Effective
   module Generators
     class DatatableGenerator < Rails::Generators::NamedBase
       include Helpers
 
-      source_root File.expand_path(('../' * 4) + 'app/scaffolds', __FILE__)
+      source_root File.expand_path(('../' * 4) + 'lib/scaffolds', __FILE__)
 
       desc 'Creates an Effective::Datatable in your app/effective/datatables folder.'
 
       argument :attributes, type: :array, default: [], banner: 'field[:type] field[:type]'
 
+      def assign_attributes
+        @attributes = (invoked_attributes.presence || klass_attributes).map do |attribute|
+          Rails::Generators::GeneratedAttribute.parse(attribute)
+        end
+
+        self.class.send(:attr_reader, :attributes)
+      end
+
+      def invoke_datatable
+        say_status :invoke, :datatable, :white
+      end
+
       def create_datatable
-        template 'datatables/datatable.rb', File.join('app/models/effective/datatables', class_path, "#{file_name}.rb")
+        template 'datatables/datatable.rb', File.join('app/models/effective/datatables', namespace_path, "#{plural_name}.rb")
       end
 
     end