effective_resources 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c009d7e3ecdcedf8d6237f147268f258cb1def21
-  data.tar.gz: e626bb392c315716a7f8805a0ec43fee41aa2543
+  metadata.gz: c81fb1d207d2a80098702d0539cce1304db0388c
+  data.tar.gz: d588a94d7b30875b233d130c798b469e289835ae
 SHA512:
-  metadata.gz: 22d8d71e5e635de0dac748d98a99cabbcefb1a741c0705489de856274a5ce0903e355ffb0d10de19751e6e8132988dc785a1ba8ef077f47c319d232a95888b48
-  data.tar.gz: f37f7fec56ae18b3dd8e86f0cc6ff43127fd0a7150231cd2be2e43a7e42456ca8ba5d0db6089de3fcd31e7aff698ba9b28973e48c884b70d1e108447edbfbf67
+  metadata.gz: 3bffe8691feaf152e672de6fc5239fea4aa155b67fbc776d1a408388e1554290b14cdb53da6bd79346725466a167c4b5c9f003e6121e150c491492e924d659c5
+  data.tar.gz: 77d22eed11ba2e26b1b7a1082141755c64b99fe7a9c5dd7b42be97a81ee1b72e7ad0a2b907461c767d7e9e6e943eab207ba1e78b0c4e08d9b24c16cd8f2e3a8c

data/README.md

@@ -37,11 +37,11 @@ end
 
 Implements the 7 RESTful actions: `index`, `new`, `create`, `show`, `edit`, `update`, `destroy`.
 
-# Loads an appropriate `@post` type instance
-# Sets a `@page_title` (effective_pages).
-# Calls authorize as per the configured `EffectiveResources.authorization_method` (flow through to CanCan or Pundit)
-# Does the create/update save
-# Sets a `flash[:success]` and redirects on success, or sets a `flash.now[:danger]` and renders on error.
+- Loads an appropriate `@post` type instance
+- Sets a `@page_title` (effective_pages).
+- Calls authorize as per the configured `EffectiveResources.authorization_method` (flow through to CanCan or Pundit)
+- Does the create/update save
+- Sets a `flash[:success]` and redirects on success, or sets a `flash.now[:danger]` and renders on error.
 
 ## Helpers
 

data/app/controllers/concerns/effective/crud_controller.rb

@@ -9,11 +9,14 @@ module Effective
     end
 
     def index
-      @page_title ||= resource_name.pluralize.titleize
+      @page_title ||= resource_plural_name.titleize
       EffectiveResources.authorized?(self, :index, resource_class)
 
       self.resources ||= resource_class.all
-      @datatable ||= resource_datatable_class.new(params[:scopes])
+
+      if resource_datatable_class
+        @datatable ||= resource_datatable_class.new(params[:scopes])
+      end
     end
 
     def new
@@ -79,7 +82,7 @@ module Effective
         flash[:danger] = "Unable to delete #{resource_name}: #{resource.errors.full_messages.to_sentence}"
       end
 
-      request.referer.present? ? redirect_to(request.referer) : redirect_to(resources_path)
+      request.referer.present? ? redirect_to(request.referer) : redirect_to(send(resource_index_path))
     end
 
     protected
@@ -93,66 +96,51 @@ module Effective
     end
 
     def resources # @things
-      send(:instance_variable_get, "@#{resource_name.pluralize}")
+      send(:instance_variable_get, "@#{resource_plural_name}")
     end
 
     def resources=(instance)
-      send(:instance_variable_set, "@#{resource_name.pluralize}", instance)
+      send(:instance_variable_set, "@#{resource_plural_name}", instance)
     end
 
     def resource_class # Thing
-      resource_namespaced_name.classify.safe_constantize || resource_name.classify.constantize
+      effective_resource.klass
     end
 
     def resource_name # 'thing'
-      controller_path.split('/').last.singularize
+      effective_resource.name
     end
 
-    def resource_namespace # ['admin']
-      controller_path.split('/')[0..-2].presence
+    def resource_plural_name # 'things'
+      effective_resource.plural_name
     end
 
-    def resource_namespaced_name # 'Admin::Thing'
-      ([resource_namespace, resource_name].compact * '/').singularize.camelize
-    end
-
-    def resource_datatable_class
-      if defined?(EffectiveDatatables)
-        "#{resource_namespaced_name.pluralize}Datatable".safe_constantize ||
-        "#{resource_name.pluralize.camelize}Datatable".safe_constantize ||
-        "Effective::Datatables::#{resource_namespaced_name.pluralize}".safe_constantize ||
-        "Effective::Datatables::#{resource_name.pluralize.camelize}".safe_constantize
-      end
+    def resource_datatable_class # ThingsDatatable
+      effective_resource.datatable_klass
     end
 
     def resource_params_method_name
-      ["#{resource_name}_params", "#{resource_name.pluralize}_params", 'permitted_params'].find { |name| respond_to?(name, true) } || 'params'
-    end
-
-    def resources_path # /admin/things
-      send([resource_namespace, resource_name.pluralize, 'path'].compact.join('_'))
+      ["#{resource_name}_params", "#{resource_plural_name}_params", 'permitted_params'].find { |name| respond_to?(name, true) } || 'params'
     end
 
-    def new_resource_path # /admin/things/new
-      send(['new', resource_namespace, resource_name, 'path'].compact.join('_'))
-    end
-
-    def edit_resource_path # /admin/things/1/edit
-      send(['edit', resource_namespace, resource_name, 'path'].compact.join('_'), resource)
-    end
-
-    def resource_path # /admin/things/1
-      send([resource_namespace, resource_name, 'path'].compact.join('_'), resource)
+    def resource_index_path
+      effective_resource.index_path
     end
 
     def resource_redirect_path
       case params[:commit].to_s
-      when 'Save'               ; edit_resource_path
-      when 'Save and Continue'  ; resources_path
-      when 'Save and Add New'   ; new_resource_path
-      else resource_path
+      when 'Save'               ; send(effective_resource.edit_path, resource)
+      when 'Save and Continue'  ; send(effective_resource.index_path)
+      when 'Save and Add New'   ; send(effective_resource.new_path)
+      else send(effective_resource.show_path, resource)
       end
     end
 
+    private
+
+    def effective_resource
+      @_effective_resource ||= Effective::Resource.new(controller_path)
+    end
+
   end
 end

data/app/models/effective/attribute.rb

@@ -0,0 +1,59 @@
+module Effective
+  class Attribute
+    attr_accessor :name, :type
+
+    REGEX = /^\W*(\w+)\W*:(\w+)/
+
+    def self.parse(input)
+      input = input.to_s
+
+      if (scanned = input.scan(REGEX).first).present?
+        new(*scanned)
+      elsif input.start_with?('#')
+        new(nil)
+      else
+        new(input)
+      end
+    end
+
+    def initialize(name, type = nil, options = {})
+      @name = name.to_s
+      @type = (type.presence || :string).to_sym
+      @options = options
+    end
+
+    def to_s
+      name
+    end
+
+    def field_type
+      @field_type ||= case type
+        when :integer              then :number_field
+        when :float, :decimal      then :text_field
+        when :time                 then :time_select
+        when :datetime, :timestamp then :datetime_select
+        when :date                 then :date_select
+        when :text                 then :text_area
+        when :boolean              then :check_box
+        else :text_field
+      end
+    end
+
+    def present?
+      name.present?
+    end
+
+    def human_name
+      name.humanize
+    end
+
+    def <=>(other)
+      name <=> other.name
+    end
+
+    def ==(other)
+      name == other.name && type == other.type
+    end
+
+  end
+end

data/app/models/effective/code_reader.rb

@@ -0,0 +1,62 @@
+module Effective
+  class CodeReader
+    attr_reader :lines
+
+    def initialize(filename, &block)
+      @lines = File.open(filename).readlines
+      block.call(self) if block_given?
+    end
+
+    # Iterate over the lines with a depth, and passed the stripped line to the passed block
+    def each_with_depth(from: nil, to: nil, &block)
+      Array(lines).each_with_index do |line, index|
+        next if index < (from || 0)
+
+        depth = line.length - line.lstrip.length
+        block.call(line.strip, depth, index)
+
+        break if to == index
+      end
+
+      nil
+    end
+
+    # Returns the index of the first line where the passed block returns true
+    def index(from: nil, to: nil, &block)
+      each_with_depth(from: from, to: to) do |line, depth, index|
+        return index if block.call(line, depth, index)
+      end
+    end
+
+    # Returns the stripped contents of the line in which the passed block returns true
+    def first(from: nil, to: nil, &block)
+      each_with_depth(from: from, to: to) do |line, depth, index|
+        return line if block.call(line, depth, index)
+      end
+    end
+    alias_method :find, :first
+
+    # Returns the stripped contents of the last line where the passed block returns true
+    def last(from: nil, to: nil, &block)
+      retval = nil
+
+      each_with_depth(from: from, to: nil) do |line, depth, index|
+        retval = line if block.call(line, depth, index)
+      end
+
+      retval
+    end
+
+    # Returns an array of stripped lines for each line where the passed block returns true
+    def select(from: nil, to: nil, &block)
+      retval = []
+
+      each_with_depth(from: from, to: to) do |line, depth, index|
+        retval << line if (block_given? == false || block.call(line, depth, index))
+      end
+
+      retval
+    end
+
+  end
+end

data/app/models/effective/resource.rb

@@ -0,0 +1,20 @@
+module Effective
+  class Resource
+    include Effective::Resources::Associations
+    include Effective::Resources::Attributes
+    include Effective::Resources::Init
+    include Effective::Resources::Klass
+    include Effective::Resources::Naming
+    include Effective::Resources::Paths
+
+    # post, Post, Admin::Post, admin::Post, admin/posts, admin/post, admin/effective::post
+    def initialize(input)
+      _initialize(input)
+    end
+
+    def to_s
+      name
+    end
+
+  end
+end

data/app/models/effective/resources/associations.rb

@@ -0,0 +1,27 @@
+module Effective
+  module Resources
+    module Associations
+
+      def belong_tos
+        @belong_tos ||= klass.reflect_on_all_associations(:belongs_to)
+      end
+
+      def nested_resources
+        @nested ||= klass.reflect_on_all_autosave_associations.inject({}) do |hash, reference|
+          hash[reference] = Effective::Resource.new(reference); hash
+        end
+      end
+
+      def has_manys
+      end
+
+      def scopes
+      end
+
+    end
+  end
+end
+
+
+
+

data/app/models/effective/resources/attributes.rb

@@ -0,0 +1,67 @@
+module Effective
+  module Resources
+    module Attributes
+
+      def attributes
+        (klass_attributes.presence || written_attributes.presence)
+      end
+
+      def attribute_names
+        attributes.map { |attribute| attribute.name }
+      end
+
+      # All attributes from the klass, sorted as per attributes block.
+      # Does not include :id, :created_at, :updated_at
+      def klass_attributes
+        attributes = (klass.new().attributes rescue nil)
+        return [] unless attributes
+
+        attributes = (attributes.keys - [klass.primary_key, 'created_at', 'updated_at'] - belong_tos.map { |reference| reference.foreign_key }).map do |att|
+          if klass.respond_to?(:column_for_attribute) # Rails 4+
+            Effective::Attribute.new(att, klass.column_for_attribute(att).try(:type))
+          else
+            Effective::Attribute.new(att, klass.columns_hash[att].try(:type))
+          end
+        end
+
+        sort(attributes)
+      end
+
+      def belong_tos_attributes
+        belong_tos.map do |reference|
+          unless reference.foreign_key == 'site_id' && klass.respond_to?(:acts_as_site_specific)
+            Effective::Attribute.new(reference.foreign_key, :integer)
+          end
+        end.compact.sort
+      end
+
+      def written_attributes
+        _initialize_written if @written_attributes.nil?
+        @written_attributes
+      end
+
+      private
+
+      def sort(attributes)
+        attributes.sort do |a, b|
+          index = nil
+
+          index ||= if written_attributes.include?(a) && written_attributes.include?(b)
+            written_attributes.index(a) <=> written_attributes.index(b)
+          elsif written_attributes.include?(a) && !written_attributes.include?(b)
+            -1
+          elsif !written_attributes.include?(a) && written_attributes.include?(b)
+            1
+          end
+
+          index || a <=> b
+        end
+      end
+
+    end
+  end
+end
+
+
+
+

data/app/models/effective/resources/init.rb

@@ -0,0 +1,50 @@
+module Effective
+  module Resources
+    module Init
+
+      private
+
+      def _initialize(input)
+        @input_name = _initialize_input_name(input)
+      end
+
+      def _initialize_input_name(input)
+        case input
+        when String ; input
+        when Symbol ; input
+        when Class  ; input.name
+        when ActiveRecord::Reflection::MacroReflection ; input.name
+        when nil    ; raise 'expected a string or class'
+        else        ; input.class.name
+        end.to_s.downcase
+      end
+
+      # Lazy initialized
+      def _initialize_written
+        @written_attributes = []
+        @written_belong_tos = []
+        @written_scopes = []
+
+        Effective::CodeReader.new(model_file) do |reader|
+          first = reader.index { |line| line == '# Attributes' }
+          last = reader.index(from: first) { |line| line.start_with?('#') == false && line.length > 0 } if first
+
+          if first && last
+            @written_attributes = reader.select(from: first+1, to: last-1).map do |line|
+              Effective::Attribute.parse(line).presence
+            end.compact
+          end
+
+          @written_belong_tos = reader.select { |line| line.start_with?('belongs_to ') }.map do |line|
+            line.scan(/belongs_to\s+:(\w+)/).flatten.first
+          end
+
+          @written_scopes = reader.select { |line| line.start_with?('scope ') }.map do |line|
+            line.scan(/scope\s+:(\w+)/).flatten.first
+          end
+        end
+      end
+
+    end
+  end
+end

data/app/models/effective/resources/klass.rb

@@ -0,0 +1,22 @@
+module Effective
+  module Resources
+    module Klass
+
+      def klass
+        namespaced_class_name.safe_constantize || class_name.safe_constantize || name.constantize
+      end
+
+      def datatable_klass
+        @datatable_klass ||= if defined?(EffectiveDatatables)
+          "#{namespaced_class_name.pluralize}Datatable".safe_constantize ||
+          "#{class_name.pluralize.camelize}Datatable".safe_constantize ||
+          "#{name.pluralize.camelize}Datatable".safe_constantize ||
+          "Effective::Datatables::#{namespaced_class_name.pluralize}".safe_constantize ||
+          "Effective::Datatables::#{class_name.pluralize.camelize}".safe_constantize ||
+          "Effective::Datatables::#{name.pluralize.camelize}".safe_constantize
+        end
+      end
+
+    end
+  end
+end

data/app/models/effective/resources/naming.rb

@@ -0,0 +1,40 @@
+module Effective
+  module Resources
+    module Naming
+      SPLIT = /\/|::/  # / or ::
+
+      def name # 'post'
+        @name ||= @input_name.split(SPLIT).last.singularize
+      end
+
+      def plural_name # 'posts'
+        name.pluralize
+      end
+
+      def class_name # 'Effective::Post'
+        @class_name ||= (@input_name.split(SPLIT) - namespaces).map { |name| name.classify } * '::'
+      end
+
+      def class_path # 'effective'
+        class_name.split('::')[0...-1].map { |name| name.underscore } * '/'
+      end
+
+      def namespaced_class_name # 'Admin::Effective::Post'
+        (namespaces.map { |name| name.classify } + [class_name]) * '::'
+      end
+
+      def namespace # 'admin/things'
+        @namespace ||= (namespaces.join('/') if namespaces.present?)
+      end
+
+      def namespaces # ['admin', 'things']
+        @namespaces ||= @input_name.split('/')[0...-1]
+      end
+
+      def human_name
+        class_name.gsub('::', ' ')
+      end
+
+    end
+  end
+end

data/app/models/effective/resources/paths.rb

@@ -0,0 +1,61 @@
+module Effective
+  module Resources
+    module Paths
+
+      # Controller REST helper paths
+      def index_path
+        [namespace, plural_name, 'path'].compact * '_'
+      end
+
+      def new_path
+        ['new', namespace, name, 'path'].compact * '_'
+      end
+
+      def show_path
+        [namespace, name, 'path'].compact * '_'
+      end
+
+      def edit_path
+        ['edit', namespace, name, 'path'].compact * '_'
+      end
+
+      def action_path(action)
+        [action, namespace, name, 'path'].compact * '_'
+      end
+
+      # _helper methods also put in the (@thing)
+      alias_method :index_path_helper, :index_path
+      alias_method :new_path_helper, :new_path
+
+      def show_path_helper(at: true)
+        show_path + '(' + (at ? '@' : '') + name + ')'
+      end
+
+      def edit_path_helper(at: true)
+        edit_path + '(' + (at ? '@' : '') + name + ')'
+      end
+
+      def action_path_helper(action, at: true)
+        action_path(action) + '(' + (at ? '@' : '') + name + ')'
+      end
+
+      # Default file paths
+      def model_file
+        File.join('app/models', class_path.to_s, "#{name}.rb")
+      end
+
+      def controller_file
+        File.join('app/controllers', namespace.to_s, "#{plural_name}_controller.rb")
+      end
+
+      def datatable_file
+        File.join('app/datatables', namespace.to_s, "#{plural_name}_datatable.rb")
+      end
+
+      def view_file(action = :index, partial: false)
+        File.join('app/views', namespace.to_s, (namespace.present? ? '' : class_path), plural_name, "#{'_' if partial}#{action}.html.haml")
+      end
+
+    end
+  end
+end

data/lib/effective_resources/version.rb

@@ -1,3 +1,3 @@
 module EffectiveResources
-  VERSION = '0.1.0'.freeze
+  VERSION = '0.1.1'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_resources
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Code and Effect
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-10 00:00:00.000000000 Z
+date: 2017-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -36,6 +36,15 @@ files:
 - app/controllers/concerns/effective/crud_controller.rb
 - app/helpers/effective_resources_helper.rb
 - app/models/effective/access_denied.rb
+- app/models/effective/attribute.rb
+- app/models/effective/code_reader.rb
+- app/models/effective/resource.rb
+- app/models/effective/resources/associations.rb
+- app/models/effective/resources/attributes.rb
+- app/models/effective/resources/init.rb
+- app/models/effective/resources/klass.rb
+- app/models/effective/resources/naming.rb
+- app/models/effective/resources/paths.rb
 - config/effective_resources.rb
 - lib/effective_resources.rb
 - lib/effective_resources/engine.rb