aenea 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1a6c10dd3f1bfe6878023fcd755f6a773debcee6ccdbc291431959cb9e3896fe
+  data.tar.gz: 93350dc6788176465e3ada046b17239a09669528ce3fc3973cd98b400b5270ca
+SHA512:
+  metadata.gz: 4a85e94f01136b1c95dfc3e6a251e781fa587fb84601ac7f6019374b73b12ef97ca81a881933a11184aeba10ef1c87c057d65bd006edf5b9afccac73f1ed6a3d
+  data.tar.gz: dc0e8c8152cdf8737ec8a12bce9ae529f63d1c20c29241d9374e5ccd79d517ccde09db6069720458d72a8b27f4d6230e2119db060f7d42b6b44d18067af5019c

data/README.md

@@ -0,0 +1,39 @@
+# Aenea
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/aenea`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'aenea'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install aenea
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/wangthony/aenea. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## Code of Conduct
+
+Everyone interacting in the Aenea project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/wangthony/aenea/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,24 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'bundler/gem_tasks'
+
+require 'rdoc/task'
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Aenea'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  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'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task default: :spec

data/app/helpers/inline_boolean_input.rb

@@ -0,0 +1,9 @@
+class InlineBooleanInput < Formtastic::Inputs::BooleanInput
+  def label_text_with_embedded_checkbox
+    label_text << '' << check_box_html
+  end
+
+  def label_html_options
+    super.merge(class: 'inline_boolean_label')
+  end
+end

data/app/helpers/markdown_input.rb

@@ -0,0 +1,21 @@
+class MarkdownInput < ::Formtastic::Inputs::TextInput
+  def to_html
+    input_wrapping do
+      label_html <<
+        builder.text_area(method, input_html_options) <<
+        template.content_tag(:div, '', class: 'markdown-input__preview', 'data-images': images_json) <<
+        template.render(partial: '/admin/shared/markdown_input/images', object: options[:images]) <<
+        template.render(partial: '/admin/shared/markdown_input/guide')
+    end
+  end
+
+  private
+
+  def images_json
+    return '' unless options[:images].present?
+
+    data = options[:images].map {|ci| [ ci.link_def_key, ci.image.url ] }
+
+    template.send :html_escape, data.to_json
+  end
+end

data/app/helpers/non_input_input.rb

@@ -0,0 +1,7 @@
+class NonInputInput < ::Formtastic::Inputs::StringInput
+  def to_html
+    input_wrapping do
+      label_html << template.content_tag(:div, options[:content], class: 'non_input_content')
+    end
+  end
+end

data/app/models/concerns/acts_as_only_flagged.rb

@@ -0,0 +1,65 @@
+module ActsAsOnlyFlagged
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def acts_as_only_flagged(parent_association, child_association, flag_attr)
+      children_name = child_association.to_s
+      child_name = children_name.singularize
+
+      set_first_child_method = "set_#{flag_attr}_on_first_#{child_name}".to_sym
+      update_siblings_method = "update_#{flag_attr}_on_sibling_#{children_name}".to_sym
+      find_siblings_method = "find_#{parent_association}_other_#{children_name}".to_sym
+
+      before_save set_first_child_method
+
+      define_method set_first_child_method do
+        siblings = send(find_siblings_method)
+        send("#{flag_attr}=", true) if siblings.empty?
+      end
+
+      after_save update_siblings_method
+
+      define_method update_siblings_method do
+        if send(flag_attr)
+          siblings = send(find_siblings_method)
+          siblings.update_all(flag_attr => false) unless siblings.empty?
+        end
+      end
+
+      define_method find_siblings_method do
+        # handle nil parent
+        return [] unless parent = send(parent_association)
+
+        parent.send(child_association).where.not(id: id)
+      end
+    end
+
+    def acts_as_only_flagged_enum(enum_name, flag_attr)
+      set_first_of_same_enum_method = "set_#{flag_attr}_on_first_of_#{enum_name}".to_sym
+      update_others_of_same_enum_method = "update_#{flag_attr}_on_others_of_#{enum_name}".to_sym
+      find_others_of_same_enum_method = "find_others_of_#{enum_name}".to_sym
+
+      before_save set_first_of_same_enum_method
+
+      define_method set_first_of_same_enum_method do
+        others = send(find_others_of_same_enum_method)
+        send("#{flag_attr}=", true) if others.empty?
+      end
+
+      after_save update_others_of_same_enum_method
+
+      define_method update_others_of_same_enum_method do
+        if send(flag_attr)
+          others = send(find_others_of_same_enum_method)
+          others.update_all(flag_attr => false) unless others.empty?
+        end
+      end
+
+      define_method find_others_of_same_enum_method do
+        enum_value = send(enum_name)
+
+        self.class.send(enum_value).where.not(id: id)
+      end
+    end
+  end
+end

data/app/models/concerns/can_be_inactive.rb

@@ -0,0 +1,8 @@
+module CanBeInactive
+  extend ActiveSupport::Concern
+
+  included do
+    scope :active, -> { where(inactive: false) }
+    scope :inactive, -> { where(inactive: true) }
+  end
+end

data/app/models/concerns/has_external_id.rb

@@ -0,0 +1,9 @@
+module HasExternalId
+  extend ActiveSupport::Concern
+
+  included do
+    validates :external_id, presence: true, uniqueness: true
+
+    before_validation {|record| record.external_id ||= SecureRandom.urlsafe_base64(32) }
+  end
+end

data/app/models/concerns/has_obfuscated_id.rb

@@ -0,0 +1,51 @@
+module HasObfuscatedId
+  extend ActiveSupport::Concern
+
+  included do
+    cattr_accessor :obsfucator
+    self.obsfucator = Obfuscator.new(name) # IDs change when class name changes
+  end
+
+  def obfuscated_id
+    return nil unless id.present?
+
+    @obfuscated_id ||= self.class.obsfucator.encrypt(id)
+  end
+
+  def to_param
+    obfuscated_id
+  end
+
+  module ClassMethods
+    def find_by_obfuscated_id!(obfuscated_id)
+      find(obsfucator.decrypt(obfuscated_id))
+    end
+
+    def find_by_obfuscated_id(obfuscated_id)
+      begin
+        find_by_obfuscated_id!(obfuscated_id)
+      rescue ActiveRecord::RecordNotFound
+        nil
+      end
+    end
+  end
+
+  class Obfuscator
+    def initialize(key)
+      @cipher = OpenSSL::Cipher::Cipher.new('aes-256-cbc')
+      @cipher_key = Digest::SHA256.digest(key)
+    end
+
+    def encrypt(value)
+      c = @cipher.encrypt
+      c.key = @cipher_key
+      Base64.urlsafe_encode64(c.update(value.to_s) + c.final) rescue nil
+    end
+
+    def decrypt(value)
+      c = @cipher.decrypt
+      c.key = @cipher_key
+      c.update(Base64.urlsafe_decode64(value.to_s)) + c.final rescue nil
+    end
+  end
+end

data/app/models/concerns/model.rb

@@ -0,0 +1,51 @@
+module Model
+  extend ActiveSupport::Concern
+
+  included do
+    cattr_accessor :associations_registry
+
+    include ActiveModel::Model
+    include ActiveModelAttributes
+    include ActiveModel::Validations::Callbacks
+
+    include BelongsTo
+    include HasOne
+    include HasMany
+    include Enum
+  end
+
+  def base_attributes
+    Hash[self.class.attributes_registry.map {|attr_name, attr_args| [ attr_name.to_s, send(attr_name).to_s ] }]
+  end
+
+  def attributes(options = {})
+    attrs = base_attributes
+
+    (self.class.associations_registry || {}).each do |assoc, type|
+      next unless (value = send(assoc)).present?
+
+      attrs["#{assoc}_attributes"] = case type
+      when :has_many
+        if options[:as_params]
+          Hash[value.each_with_index.map {|obj, i| [ i.to_s, obj.attributes(options) ] }]
+        else
+          value.map {|obj| obj.attributes(options) }
+        end
+      when :has_one
+        value.attributes(options)
+      else
+        raise "invalid association type #{type} for #{assoc}"
+      end
+    end
+
+    attrs
+  end
+
+  def to_params
+    attributes(as_params: true)
+  end
+
+  def marked_for_destruction?
+    false
+  end
+end

data/app/models/concerns/model/belongs_to.rb

@@ -0,0 +1,38 @@
+module Model
+  module BelongsTo
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def belongs_to(name, options = {})
+        id_attr = "#{name}_id"
+
+        belongs_to_reader id_attr, name, options
+        belongs_to_writer id_attr, name, options
+
+        validates name, presence: true unless options[:optional]
+      end
+
+      private
+
+      def belongs_to_reader(id_attr, name, options)
+        define_method name do
+          class_name = options[:polymorphic] ? send("#{name}_type") : name.to_s.camelize
+          klass = class_name.blank? ? nil : class_name.constantize
+          id = send(id_attr)
+
+          klass && id ? klass.find(id) : nil
+        end
+      end
+
+      def belongs_to_writer(id_attr, name, options)
+        define_method "#{name}=" do |object|
+          value = object.try(:id)
+          send "#{id_attr}=", value
+          send("#{name}_type=", value ? object.class.name : nil) if options[:polymorphic]
+
+          value
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/model/enum.rb

@@ -0,0 +1,24 @@
+module Model
+  module Enum
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def enum(attr_name, enum_class_name)
+        klass = enum_class_name.constantize
+        keys = klass.send(attr_name.to_s.pluralize).keys
+
+        keys.each do |key|
+          define_method "#{key}?" do
+            send(attr_name) == key
+          end
+        end
+
+        validates attr_name, inclusion: { in: keys } # allow nil values
+
+        define_method "formatted_#{attr_name}" do
+          send(attr_name).titleize
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/model/has_many.rb

@@ -0,0 +1,127 @@
+module Model
+  module HasMany
+    extend ActiveSupport::Concern
+
+    class Association
+      attr_reader :target, :assoc, :singular_name
+
+      def initialize(target, assoc, options = {})
+        @target = target
+        @assoc = assoc.to_sym
+
+        @singular_name = assoc.to_s.singularize
+        raise 'assoc must be plural' if singular_name == assoc.to_s
+
+        class_name = options[:class_name] || singular_name.to_s.camelize
+        klass = class_name.constantize
+
+        var_name = "@#{assoc}".to_sym
+        builder_method_name = "build_#{singular_name}".to_sym
+        selector_method_name = "#{assoc}_with".to_sym
+        finder_method_name = "find_#{singular_name}_with".to_sym
+        validate_method_name = "validate_associated_#{assoc}".to_sym
+
+        define_reader var_name
+        define_attributes_writer var_name, builder_method_name
+        define_builder builder_method_name, klass, assoc
+        define_selector selector_method_name, assoc
+        define_finder finder_method_name, selector_method_name
+        define_find_or_build_method finder_method_name, builder_method_name
+        define_present_method assoc
+        define_empty_method assoc
+        define_validate_method validate_method_name, assoc
+
+        if validate_options = options[:validate]
+          target.validate validate_method_name, validate_options.is_a?(Hash) ? validate_options : {}
+        end
+      end
+
+      private
+
+      def define_reader(var_name)
+        # def things
+        target.send :define_method, assoc do
+          instance_variable_get(var_name) || instance_variable_set(var_name, []) # always return non-nil value
+        end
+      end
+
+      def define_attributes_writer(var_name, builder_method_name)
+        # def things_attributes=(params)
+        target.send :define_method, "#{assoc}_attributes=" do |params|
+          values = params.is_a?(Array) ? params : params.values # Hash or ActiveSupport::HashWithIndifferentAccess
+          instance_variable_set var_name, values.map {|attrs| send(builder_method_name, attrs) }
+        end
+      end
+
+      def define_builder(builder_method_name, klass, assoc)
+        # def build_thing(attrs = {})
+        target.send :define_method, builder_method_name do |attrs = {}|
+          obj = klass.new(attrs)
+          send(assoc) << obj
+
+          obj
+        end
+      end
+
+      def define_selector(selector_method_name, assoc)
+        # def things_with(attrs)
+        target.send :define_method, selector_method_name do |attrs|
+          send(assoc).select {|obj|
+            found = true
+            attrs.each do |key, value|
+              unless obj.send(key) == value
+                found = false
+                break
+              end
+            end
+
+            found
+          }
+        end
+      end
+
+      def define_finder(finder_method_name, selector_method_name)
+        # def find_thing_with(attrs)
+        target.send :define_method, finder_method_name do |attrs|
+          send(selector_method_name, attrs).first
+        end
+      end
+
+      def define_find_or_build_method(finder_method_name, builder_method_name)
+        # def find_or_build_thing_with(attrs)
+        target.send :define_method, "find_or_build_#{singular_name}_with" do |attrs|
+          send(finder_method_name, attrs) || send(builder_method_name, attrs)
+        end
+      end
+
+      def define_present_method(assoc)
+        # def things_present?
+        target.send :define_method, "#{assoc}_present?" do
+          send(assoc).present?
+        end
+      end
+
+      def define_empty_method(assoc)
+        # def things_empty?
+        target.send :define_method, "#{assoc}_empty?" do
+          send(assoc).empty?
+        end
+      end
+
+      def define_validate_method(validate_method_name, assoc)
+        # def validate_associated_things
+        target.send :define_method, validate_method_name do
+          errors.add assoc, 'is invalid' unless send(assoc).inject(true) {|valid, obj| valid = valid && obj.valid? }
+        end
+      end
+    end
+
+    module ClassMethods
+      def has_many(name, options = {})
+        (self.associations_registry ||= {})[name] = :has_many
+
+        Association.new self, name, options
+      end
+    end
+  end
+end