abyme 0.2.1 → 0.5.0

data/Rakefile

@@ -1,6 +1,51 @@
-require "bundler/gem_tasks"
+# require "bundler/gem_tasks"
 require "rspec/core/rake_task"
+# require 'rails/dummy/tasks'
 
 RSpec::Core::RakeTask.new(:spec)
-
 task :default => :spec
+
+# APP_RAKEFILE = File.expand_path("spec/dummy/Rakefile", __dir__)
+# load 'rails/tasks/engine.rake'
+# load 'rails/tasks/statistics.rake'
+
+# Bundler::GemHelper.install_tasks
+
+# begin
+#   require 'bundler/setup'
+# rescue LoadError
+#   puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+# end
+
+# require 'rdoc/task'
+
+# RDoc::Task.new(:rdoc) do |rdoc|
+#   rdoc.rdoc_dir = 'rdoc'
+#   rdoc.title    = 'Abyme'
+#   rdoc.options << '--line-numbers'
+#   rdoc.rdoc_files.include('README.md')
+#   rdoc.rdoc_files.include('lib/**/*.rb')
+# end
+
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'SampleEngineWithRspecAndCucumber'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("spec/dummy/Rakefile", __dir__)
+
+load 'rails/tasks/engine.rake'
+load 'rails/tasks/statistics.rake'
+
+Bundler::GemHelper.install_tasks

data/abyme.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |spec|
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|node_modules)/}) }
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
@@ -28,5 +28,21 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 2.0"
   spec.add_development_dependency "rake", "~> 13.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
+  # Tests
+  spec.add_development_dependency "rspec-rails"
+  spec.add_development_dependency 'rails-controller-testing'
+  spec.add_development_dependency 'database_cleaner-active_record'
+  spec.add_development_dependency 'capybara'
+  spec.add_development_dependency 'webdrivers'
+  spec.add_development_dependency "generator_spec"
+  
+  # Dummy app
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency 'rails'
+  spec.add_development_dependency 'pry-rails'
+  spec.add_development_dependency 'web-console'
+
+  spec.add_development_dependency 'puma'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'simplecov-lcov'
 end

data/bin/rails

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails 4 gems installed from the root of your application.
+
+ENGINE_ROOT = File.expand_path('..', __dir__)
+ENGINE_PATH = File.expand_path('../lib/abyme/engine', __dir__)
+
+# Set up gems listed in the Gemfile.
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
+require 'bundler/setup' if File.exist?(ENV['BUNDLE_GEMFILE'])
+
+require 'rails/all'
+require 'rails/engine/commands'

data/javascript/abyme_controller.js

@@ -1,27 +1,62 @@
 import { Controller } from 'stimulus';
 
 export default class extends Controller {
-  static targets = ['template', 'associations', 'fields', 'newFields'];
+  // static targets = ['template', 'associations', 'fields', 'newFields'];
+  // Some applications don't compile correctly with the usual static syntax. 
+  // Thus implementing targets with standard getters below
+
+  static get targets() {
+    return ['template', 'associations', 'fields', 'newFields'];
+  } 
 
   connect() {
+    console.log("Abyme Connected")
+
     if (this.count) {
-      this.addDefaultAssociations();
+      // If data-count is present,
+      // add n default fields on page load
+
+      this.add_default_associations();
     }
   }
 
+  // return the value of the data-count attribute
+
   get count() {
     return this.element.dataset.minCount || 0;
   }
   
+  // return the value of the data-position attribute
+  // if there is no position specified set end as default
+
   get position() {
     return this.associationsTarget.dataset.abymePosition === 'end' ? 'beforeend' : 'afterbegin';
   }
 
+  // ADD_ASSOCIATION
+
+  // this function is call whenever a click occurs
+  // on the element with the click->abyme#add_association
+  // <button> element by default
+
+  // if a data-count is present the add_association
+  // will be call without an event so we have to check
+  // this case
+
+  // check for limit reached 
+  // dispatch an event if the limit is reached
+
+  // - call the function build_html that take care
+  //   for building the correct html to be inserted in the DOM
+  // - dispatch an event before insert
+  // - insert html into the dom
+  // - dispatch an event after insert
+
   add_association(event) {
     if (event) {
       event.preventDefault();
     }
-    // check for limit reached
+
     if (this.element.dataset.limit && this.limit_check()) {
       this.create_event('limit-reached')
       return false
@@ -33,8 +68,21 @@ export default class extends Controller {
     this.create_event('after-add');
   }
 
+  // REMOVE_ASSOCIATION
+
+  // this function is call whenever a click occurs
+  // on the element with the click->abyme#remove_association
+  // <button> element by default
+
+  // - call the function mark_for_destroy that takes care
+  //   of marking the element for destruction and hiding it
+  // - dispatch an event before mark & hide
+  // - mark for descrution + hide the element
+  // - dispatch an event after mark and hide
+
   remove_association(event) {
     event.preventDefault();
+
     this.create_event('before-remove');
     this.mark_for_destroy(event);
     this.create_event('after-remove');
@@ -42,6 +90,12 @@ export default class extends Controller {
 
   // LIFECYCLE EVENTS RELATED
 
+  // CREATE_EVENT
+
+  // take a stage (String) => before-add, after-add...
+  // create a new custom event 
+  // and dispatch at at the controller level
+
   create_event(stage, html = null) {
     const event = new CustomEvent(`abyme:${stage}`, { detail: {controller: this, content: html} });
     this.element.dispatchEvent(event);
@@ -69,9 +123,14 @@ export default class extends Controller {
   abymeAfterRemove(event) {
   }
 
-  // UTILITIES
+  // BUILD HTML
+
+  // takes the html template and substitutes the sub-string
+  // NEW_RECORD for a generated timestamp
+  // then if there is a sub template in the html (multiple nested level)
+  // set all the sub timestamps back as NEW_RECORD
+  // finally returns the html  
 
-  // build html
   build_html() {
     let html = this.templateTarget.innerHTML.replace(
       /NEW_RECORD/g,
@@ -88,8 +147,15 @@ export default class extends Controller {
 
     return html;
   }
-    
-  // mark association for destroy
+  
+  // MARK_FOR_DESTROY
+
+  // mark association for destruction
+  // get the closest abyme--fields from the remove_association button
+  // set the _destroy input value as 1
+  // hide the element
+  // add the class of abyme--marked-for-destroy to the element
+
   mark_for_destroy(event) {
     let item = event.target.closest('.abyme--fields');
     item.querySelector("input[name*='_destroy']").value = 1;
@@ -97,20 +163,29 @@ export default class extends Controller {
     item.classList.add('abyme--marked-for-destroy')
   }
 
-  // check if associations limit is reached
+
+  // LIMIT_CHECK
+
+  // Check if associations limit is reached
+  // based on newFieldsTargets only
+  // persisted fields are ignored
+
   limit_check() {
     return (this.newFieldsTargets
                 .filter(item => !item.classList.contains('abyme--marked-for-destroy'))).length 
                 >= parseInt(this.element.dataset.limit)
   }
 
-  // Add default blank associations at page load
-  async addDefaultAssociations() {
+  // ADD_DEFAULT_ASSOCIATION
+
+  // Add n default blank associations at page load
+  // call sleep function to ensure uniqueness of timestamp
+
+  async add_default_associations() {
     let i = 0
     while (i < this.count) {
       this.add_association()
       i++
-      // Sleep function to ensure uniqueness of timestamp
       await this.sleep(1);
     }
   }

data/lib/abyme.rb

@@ -1,6 +1,8 @@
 require "abyme/version"
 require 'abyme/view_helpers'
 require 'abyme/engine'
+require 'abyme/controller'
+require 'abyme/action_view_extensions/builder'
 
 module Abyme
   class Error < StandardError; end

data/lib/abyme/abyme_builder.rb

@@ -2,31 +2,42 @@ module Abyme
   class AbymeBuilder < ActionView::Base
     include ActionView
 
-    def initialize(association:, form:, lookup_context:, partial:, &block)
+    # If a block is given to the #abymize helper 
+    # it will instanciate a new AbymeBuilder 
+    # and pass to it the association name (Symbol)
+    # the form object, lookup_context optionaly a partial path
+    # then yield itself to the block 
+
+    def initialize(association:, form:, context:, partial:, &block)
       @association = association
       @form = form
-      @lookup_context = lookup_context
+      @context = context
+      @lookup_context = context.lookup_context
       @partial = partial
       yield(self) if block_given?
     end
+
+    # RECORDS
+
+    # calls the #persisted_records_for helper method
+    # passing association, form and options to it
   
     def records(options = {})
       persisted_records_for(@association, @form, options) do |fields_for_association|
-        render_association_partial(fields_for_association, options)
+        render_association_partial(@association, fields_for_association, @partial, @context)
       end
     end
+
+    # NEW_RECORDS
+
+    # calls the #new_records_for helper method
+    # passing association, form and options to it
     
     def new_records(options = {}, &block)
       new_records_for(@association, @form, options) do |fields_for_association|
-        render_association_partial(fields_for_association, options)
+        render_association_partial(@association, fields_for_association, @partial, @context)
       end
     end
   
-    private
-
-    def render_association_partial(fields, options)
-      partial = @partial || options[:partial] || "abyme/#{@association.to_s.singularize}_fields"
-      ActionController::Base.render(partial: partial, locals: { f: fields })
-    end
   end
 end

data/lib/abyme/action_view_extensions/builder.rb

@@ -0,0 +1,15 @@
+module Abyme
+  module ActionViewExtensions
+    module Builder
+      def abyme_for(association, options = {}, &block)
+        @template.abyme_for(association, self, options, &block)
+      end
+    end
+  end
+end
+
+module ActionView::Helpers
+  class FormBuilder
+    include Abyme::ActionViewExtensions::Builder
+  end
+end

data/lib/abyme/controller.rb

@@ -0,0 +1,15 @@
+module Abyme
+  module Controller
+    def abyme_attributes
+      return [] if resource_class.nil?
+      
+      resource_class.abyme_attributes
+    end
+
+    private
+
+    def resource_class
+      self.class.name.match(/(.*)(Controller)/)[1].singularize.safe_constantize
+    end
+  end
+end

data/lib/abyme/engine.rb

@@ -4,9 +4,11 @@ module Abyme
     
     config.after_initialize do
       ActiveSupport.on_load :action_view do
-        # ActionView::Base.send :include, Abyme::ViewHelpers
         include Abyme::ViewHelpers
       end
+      ActiveSupport.on_load :action_controller do
+        include Abyme::Controller
+      end
     end
   end
 end

data/lib/abyme/model.rb

@@ -1,11 +1,85 @@
 module Abyme
   module Model
-    extend ActiveSupport::Concern
-
-    class_methods do
-      def abyme_for(association, options = {})
+    module ClassMethods
+      def abymize(association, permit: nil, reject: nil, **options)
         default_options = {reject_if: :all_blank, allow_destroy: true}
-        accepts_nested_attributes_for association, default_options.merge(options)
+        nested_attributes_options = default_options.merge(options)
+        accepts_nested_attributes_for association, nested_attributes_options
+        # Save allow_destroy value for this model/association for later
+        save_destroy_option(association, nested_attributes_options[:allow_destroy])
+        Abyme::Model.permit_attributes(self.name, association, permit || reject, permit.present?) if permit.present? || reject.present?
+      end
+
+      def abyme_attributes
+        Abyme::Model.instance_variable_get(:@permitted_attributes)[self.name]
+      end
+
+      private
+
+      def save_destroy_option(association, value)
+        Abyme::Model.instance_variable_get(:@allow_destroy)[self.name][association] = value
+      end
+    end
+
+    @permitted_attributes ||= {}
+    @allow_destroy        ||= {}
+
+    attr_accessor :allow_destroy
+    attr_reader   :permitted_attributes
+
+    def self.permit_attributes(class_name, association, attributes, permit)
+      @permitted_attributes[class_name]["#{association}_attributes".to_sym] = AttributesBuilder.new(class_name, association, attributes, permit)
+                                                                                               .build_attributes
+    end
+
+    def self.included(klass)
+      @permitted_attributes[klass.name] ||= {}
+      @allow_destroy[klass.name]        ||= {}
+      klass.extend ClassMethods
+    end
+
+    class AttributesBuilder
+      def initialize(model, association, attributes, permit = true)
+        @model = model
+        @association = association
+        @attributes_list = attributes
+        @permit = permit
+        @association_class = @association.to_s.classify.constantize
+      end
+
+      def build_attributes
+        nested_attributes = @association_class.abyme_attributes if @association_class.respond_to? :abyme_attributes
+        authorized_attributes = build_default_attributes
+        if @permit && @attributes_list == :all_attributes
+          authorized_attributes = build_all_attributes(authorized_attributes, nested_attributes)
+        elsif @permit
+          @attributes_list << nested_attributes unless (nested_attributes.blank? || @attributes_list.include?(nested_attributes))
+          authorized_attributes += @attributes_list
+        else
+          authorized_attributes = build_all_attributes(authorized_attributes, nested_attributes)
+          authorized_attributes -= @attributes_list
+        end
+        authorized_attributes
+      end
+
+      def destroy_allowed?
+        Abyme::Model.instance_variable_get(:@allow_destroy).dig(@model, @association)
+      end
+
+      def add_all_attributes
+        @association_class.column_names.map(&:to_sym).reject { |attr| [:id, :created_at, :updated_at].include?(attr) }
+      end
+
+      def build_all_attributes(authorized_attributes, nested_attributes)
+        authorized_attributes += add_all_attributes
+        authorized_attributes << nested_attributes unless (nested_attributes.blank? || authorized_attributes.include?(nested_attributes))
+        authorized_attributes
+      end
+
+      def build_default_attributes
+        attributes = [:id]
+        attributes << :_destroy if destroy_allowed?
+        attributes
       end
     end
   end