conjoin 0.0.1 → 0.0.2

data/lib/conjoin/auth.rb

@@ -0,0 +1,92 @@
+module Conjoin
+  module Auth
+    if Conjoin.env.mounted?
+      require 'warden'
+      require 'devise'
+      include Devise::TestHelpers
+    end
+
+    class << self
+      attr_accessor :app
+    end
+
+    def self.setup app
+      self.app = app
+
+      if not Conjoin.env.mounted?
+        require 'shield'
+        app.plugin Shield::Helpers
+        app.use Shield::Middleware, "/login"
+      end
+    end
+
+    def login_path
+      req.env['REQUEST_URI'][/login/] ? true : false
+    end
+
+    def logout_path
+      req.env['REQUEST_URI'][/logout/] ? true : false
+    end
+
+    def current_user
+      if not Conjoin.env.mounted?
+        authenticated(VendorWizard::User)
+      else
+        req.env['warden'].authenticate(scope: :user)
+      end
+    end
+
+    def logged_in?
+      current_user ? true : false
+    end
+
+    def sign_in *args
+      if args.length > 1
+        user, scope = args
+      else
+        scope = :user
+        user  = args.first
+      end
+
+      if Auth.app.mounted?
+        @request = req
+        super scope, user
+      else
+        session.clear
+        session['VendorWizard::User'] = user.id
+      end
+    end
+
+    class Routes < Conjoin::Cuba
+      plugin Auth
+
+      define do
+        on login_path do
+          on get do
+            user = UserLoginForm.new
+            res.write view("login", user: user)
+          end
+
+          on post do
+            user            = UserLoginForm.new
+            user.attributes = req[:user_login]
+
+            if user.valid_only?(:email, :password) && login(User, user.email, user.password)
+              res.redirect req[:return] || '/'
+            else
+              user.password = nil
+            end
+
+            res.write view("login", user: user)
+          end
+        end
+
+        on logout_path do
+          logout User
+
+          res.redirect '/'
+        end
+      end
+    end
+  end
+end

data/lib/conjoin/class_methods.rb

@@ -0,0 +1,15 @@
+module Conjoin
+  module ClassMethods
+    attr_accessor :root
+
+    def env
+      @env ||= EnvString.new(
+        ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development'
+      )
+    end
+  end
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+end

data/lib/conjoin/csrf.rb

@@ -0,0 +1,26 @@
+require "rack/csrf"
+
+module Conjoin
+  module Csrf
+    # Public: Sugar to include a csrf tag
+    #
+    # Examples:
+    #
+    #   <form action="/new">
+    #     <%= csrf_tag %>
+    #     <input type="text" />
+    #   </form>
+    def csrf_tag
+      Rack::Csrf.tag(env)
+    end
+
+    # Public: Sugar to access the csrf token
+    #
+    # Examples:
+    #
+    #   <%= csrf_token %>
+    def csrf_token
+      Rack::Csrf.token(env)
+    end
+  end
+end

data/lib/conjoin/cuba.rb

@@ -0,0 +1,72 @@
+require "cuba"
+require "cuba/render"
+
+module Conjoin
+  class Cuba < ::Cuba
+    class << self
+      def settings= settings
+        @settings = settings
+      end
+
+      def root; @root ||= Dir.pwd; end
+      def root= root
+        @root = root
+      end
+
+      def initialize!
+        # Initializers
+        Dir["#{root}/config/initializers/**/*.rb"].each  { |rb| require rb  }
+
+        # Permissions
+        Dir["#{root}/app/models/permissions/**/*.rb"].each {|rb| require rb }
+        Dir["#{root}/app/permissions/**/*.rb"].each {|rb| require rb }
+
+        # Models
+        Dir["#{root}/app/models/*/*.rb"].each {|rb| require rb }
+        Dir["#{root}/app/models/**/*.rb"].each {|rb| require rb }
+
+        # Forms
+        Dir["#{root}/app/forms/*/*.rb"].each {|rb| require rb }
+        Dir["#{root}/app/forms/**/*.rb"].each {|rb| require rb }
+
+        # Assets
+        require "#{root}/config/assets"
+
+        # Presenters
+        Dir["#{root}/app/presenters/**/*.rb"].each  { |rb| require rb  }
+
+        # Mailers
+        Dir["#{root}/app/mailers/**/*.rb"].each  { |rb| require rb  }
+
+        # Routes
+        Dir["#{root}/app/routes/**/*.rb"].each  { |rb| require rb  }
+        require "#{root}/config/routes"
+      end
+    end
+
+    module Render
+      include ::Cuba::Render
+
+      def self.setup(app)
+        app.settings[:render] ||= {}
+        app.settings[:render][:template_engine] ||= "slim"
+        app.settings[:render][:layout] ||= "layouts/app"
+        app.settings[:render][:views] ||= "#{app.root}/app/views"
+        app.settings[:render][:options] ||= {
+          default_encoding: Encoding.default_external
+        }
+      end
+
+      alias original_partial partial
+
+      def view(template, locals = {}, layout = settings[:render][:layout])
+        original_partial(layout, { content: original_partial(template, locals) }.merge(locals))
+      end
+
+      def partial template, locals = {}
+        partial_template = template.gsub(/([a-zA-Z_]+)$/, '_\1')
+        render(template_path(partial_template), locals, settings[:render][:options])
+      end
+    end
+  end
+end

data/lib/conjoin/env_string.rb

@@ -0,0 +1,17 @@
+module Conjoin
+  class EnvString < String
+    [:production, :development, :test, :staging].each do |env|
+      define_method "#{env}?" do
+        self == env.to_s
+      end
+    end
+
+    def mounted?
+      defined?(::Rails) ? true : false
+    end
+
+    def console?
+      ENV['CONJOIN_CONSOLE'] ? true : false
+    end
+  end
+end

data/lib/conjoin/form_builder.rb

@@ -0,0 +1,334 @@
+require "rack/csrf"
+
+module Conjoin
+  module FormBuilder
+    INPUTS = [
+      :boolean, :checkbox, :date, :decimal, :file, :hidden,
+      :integer, :password, :radio, :select, :state, :string,
+      :time
+    ]
+
+    def self.setup app
+      require 'mab/kernel_method'
+
+      app.use Rack::Csrf
+      app.plugin Conjoin::Csrf
+      # Dir["#{File.dirname(__FILE__)}/plugin/inputs/**/*.rb"].each  { |rb| require rb  }
+      INPUTS.each do |input|
+        require_relative "inputs/#{input}"
+      end
+
+      Dir["#{app.root}/app/inputs/**/*.rb"].each  { |rb| require rb  }
+    end
+
+    def form_for record, options = {}, &block
+      raise ArgumentError, "Missing block" unless block_given?
+
+      if as = options.delete(:as)
+        model_name = as
+      elsif record.is_form?
+        model_name = record.class.model_name.to_s.gsub(/\w+::/, '').gsub(/Form$/, '').underscore
+      else
+        model_name = record.class.model_name.singular
+      end
+
+      fields = Fields.new self, [model_name], record, block
+
+      form_options = {
+        class: 'form-horizontal',
+        role: 'form',
+        method: 'post',
+        novalidate: 'true',
+        remote: true,
+        action: options.delete(:url) || "/" + record.class.model_name.plural
+      }.merge! options
+
+      if form_options.delete(:remote)
+        form_options['data-remote'] = 'true'
+      end
+
+      mab do
+        form form_options do
+          input type: 'hidden', name: '_method', value: (record.id ? 'patch' : 'post')
+          text! csrf_tag
+          text! fields.render
+        end
+      end
+    end
+
+    class Fields < Struct.new(:app, :models, :record, :block, :index)
+      def render
+        html = block.call(self, index)
+        names = [].concat models
+        names << 'id'
+
+        mab do
+          if record.id
+            input type: 'hidden', name: nested_names_for(names), value: record.id
+          end
+          text! html
+        end
+      end
+
+      def submit options = {}
+        mab do
+          input type: 'submit',
+            value: options[:value] || 'Submit',
+            class: 'btn'
+        end
+      end
+
+      def nested_names_for names
+        # create field names that map to the correct models
+        names.each_with_index.map do |field, i|
+          i != 0 ? "[#{field}]" : field
+        end.join
+      end
+
+      def association field_name, options = {}
+        options[:is_association] = true
+        input field_name, options
+      end
+
+      def input_field field_name, options = {}
+        options[:wrapper] = false
+        input field_name, options
+      end
+
+      def input field_name, options = {}
+        names = [].concat models
+        if options.delete(:is_association)
+          names << "#{field_name.to_s.singularize}_ids"
+          names << ''
+        else
+          names << field_name
+        end
+
+        # create field names that map to the correct models
+        nested_name = nested_names_for names
+
+        record_class = record.class.model_name.name.constantize
+
+        if as = options.delete(:as)
+          record_type = as.to_s.classify
+        elsif record_class.mini_record_columns \
+          and mini_column = record_class.mini_record_columns[field_name] \
+          and input_as = mini_column[:input_as]
+            record_type = input_as.to_s.classify
+        else
+          record_type = record_class.columns_hash[field_name.to_s].type.to_s.classify
+        end
+
+        if mini_column and opts = mini_column[:input_options]
+          options = opts.merge options
+        end
+
+        input_class = "Conjoin::FormBuilder::#{record_type}Input".constantize
+
+        data = OpenStruct.new({
+          name: nested_name,
+          record: record,
+          value: record.send(field_name),
+          options: options,
+          errors: record.errors.messages[field_name],
+          names: names
+        })
+
+        new_input = input_class.new data, app, record
+
+        if record_type != 'Hidden' \
+        and not options.key(:wrapper) and options[:wrapper] != false
+          wrapper field_name.to_s, nested_name, new_input, options
+        else
+          new_input.render
+        end
+      end
+
+      def fields_for field_name, options = {}, &block
+        names = [].concat models
+
+        associated_record = record.send field_name
+
+        if scope = options.delete(:scope)
+          associated_record = associated_record.send(scope, *options.delete(:scope_args))
+        end
+
+        if select = options.delete(:select)
+          associated_record = Hash[associated_record.each_with_index.map {|a, i| [i, a]}]
+
+          select.each do |key, select_array|
+            select_array = [select_array] unless select_array.is_a? Array
+
+            associated_record.select! do |k, v|
+              select_array.include? :"#{v[key]}"
+            end
+          end
+        end
+
+        if name = options.delete(:name)
+          field_name = name
+        end
+
+        names << "#{field_name}_attributes"
+
+        if !associated_record.kind_of? ActiveRecord::Associations::CollectionProxy \
+        and !associated_record.kind_of? ActiveRecord::AssociationRelation \
+        and !associated_record.kind_of? Array \
+        and !associated_record.kind_of? Hash
+          fields = Fields.new app, names, associated_record, block, 0
+          fields.render
+        else
+          html = ''
+          if associated_record.kind_of? Array
+            associated_record.each_with_index do |current_record, i|
+              nested_names = [].concat names
+              nested_names << i
+
+              fields = Fields.new app, nested_names, current_record, block, i
+              html += fields.render
+            end
+          else
+            associated_record.each do |i, current_record|
+              nested_names = [].concat names
+              nested_names << i
+
+              fields = Fields.new app, nested_names, current_record, block, i
+              html += fields.render
+            end
+          end
+
+          html
+        end
+
+      # rescue
+      #   raise "No associated record #{field_name} for #{record.class}"
+      end
+
+      def errors_for attr
+        mab do
+          span class: 'has-error has-feedback form-control-feedback' do
+            text! record.errors.messages[attr.to_sym].try :join, ', '
+          end
+        end
+      end
+
+      private
+
+      def id_for field_name
+        field_name.gsub(/[^a-z0-9]/, '_').gsub(/__/, '_').gsub(/_$/, '')
+      end
+
+      def required?(obj, attr, options)
+        if options.key?(:required)
+          options[:required]
+        else
+          target = (obj.class == Class) ? obj : obj.class
+          presence = target.validators_on(attr).select { |t| t.class.to_s == 'ActiveRecord::Validations::PresenceValidator' }
+          if presence.any?
+            is_required = true
+
+            presence.each do |p|
+              if p.options[:if]
+                is_required &= p.options[:if].call(record)
+              end
+
+              if p.options[:unless]
+                is_required &= !p.options[:if].call(record)
+              end
+            end
+          else
+            is_required = false
+          end
+
+          is_required
+        end
+      end
+
+      def errors? obj, attr
+        obj.errors.messages[attr.to_sym]
+      end
+
+      def wrapper field_name, nested_name, input, options
+        if w = options[:wrapper] and w.is_a? String
+          label_width, input_width = w.split ','
+        else
+          label_width, input_width = [3, 9]
+        end
+
+        mab do
+          div class: "form-group #{errors?(record, field_name) ? 'has-error has-feedback' : ''}" do
+            label for: id_for(nested_name), class: "control-label col-sm-#{label_width}" do
+              if required? record, field_name, options
+                abbr title: 'required' do
+                  text '*'
+                end
+              end
+
+              i18n_s = nested_name.gsub(/.+\[([a-z\_]+)\](?:.*|)\[([a-z\_]+)\]$/, 'model.\1.\2').gsub(/_attributes/, '')
+
+              i18n_name = options[:label] || R18n.t(i18n_s.gsub(/^model/, 'form.label')) | R18n.t.form.label[field_name] | R18n.t(i18n_s) |  field_name.titleize
+
+              text! i18n_name
+            end
+            div class: "col-sm-#{input_width}" do
+              text! input.render
+              if errors = errors?(record, field_name)
+                span class: 'help-block has-error' do
+                  text errors.join ', '
+                end
+                span class: 'fa fa-times form-control-feedback'
+              end
+            end
+          end
+        end
+      end
+    end
+
+    class Input
+      attr_accessor :app, :data, :options, :record
+
+      def initialize data, app, record
+        @data = data
+        @app = app
+        @record = record
+        @options = {
+          name: data.name,
+          type: :text,
+          id: id,
+          value: data.value,
+          class: ''
+        }.merge! data.options
+        options[:class] += ' form-control'
+        @options
+      end
+
+      def id
+        data.name.gsub(/[^a-z0-9]/, '_').gsub(/__/, '_').gsub(/_$/, '')
+      end
+
+      def nested_name
+        # create field names that map to the correct models
+        data.names.each_with_index.map do |field, i|
+          i != 0 ? "[#{field}]" : field
+        end.join
+      end
+
+      def errors?
+        data.errors
+      end
+
+      def render
+        if options[:type] == :hidden \
+        or (options.key?(:wrapper) and options[:wrapper] == false)
+          options[:class] = options[:class].gsub(/form-control/, '')
+        end
+
+        display
+      end
+
+      def display
+        mab { input options }
+      end
+    end
+  end
+end