brut 0.0.1

data/lib/brut/spec_support/component_support.rb

@@ -0,0 +1,49 @@
+require_relative "flash_support"
+module Brut::SpecSupport::ComponentSupport
+  include Brut::SpecSupport::FlashSupport
+  include Brut::I18n::ForHTML
+
+  def render_and_parse(component,&block)
+    if component.kind_of?(Brut::FrontEnd::Page)
+      if !block.nil?
+        raise "pages do not accept blocks - do not pass one to render_and_parse"
+      end
+      result = component.handle!
+      case result
+      in String => html
+        Nokogiri::HTML5(html)
+      else
+        result
+      end
+    else
+      component.yielded_block = block
+      rendered_text = component.render
+      document = Nokogiri::HTML5(rendered_text)
+      component_html = document.css("body")
+      if component_html
+        non_blank_text_elements = component_html.children.select { |element|
+          if element.kind_of?(Nokogiri::XML::Text) && element.text.to_s.strip == ""
+            false
+          else
+            true
+          end
+        }
+        if non_blank_text_elements.size == 1
+          non_blank_text_elements[0]
+        else
+          raise "#{component.class} rendered #{non_blank_text_elements.size} elements other than blank text:\n\n#{non_blank_text_elements.map(&:name)}. Components should render a single element:\n#{rendered_text}"
+        end
+      else
+        raise "#{component.class} did not render HTML properly: #{rendered_text}"
+      end
+    end
+  end
+
+  def routing_for(klass,**args)
+    Brut.container.routing.uri(klass,**args)
+  end
+
+  def escape_html(...)
+    Brut::FrontEnd::Templates::EscapableFilter.escape_html(...)
+  end
+end

data/lib/brut/spec_support/flash_support.rb

@@ -0,0 +1,7 @@
+module Brut::SpecSupport::FlashSupport
+  def empty_flash = Brut.container.flash_class.new
+
+  def flash_from(hash)
+    Brut.container.flash_class.from_h(messages: hash)
+  end
+end

data/lib/brut/spec_support/general_support.rb

@@ -0,0 +1,18 @@
+module Brut::SpecSupport::GeneralSupport
+  def self.included(mod)
+    mod.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def implementation_is_trivial
+      it "has no tests because the implementation is trivial" do
+        expect(true).to eq(true)
+      end
+    end
+    def implementation_is_covered_by_other_tests(description)
+      it "has no tests because the implementation is sufficiently covered by other tests: #{description}" do
+        expect(true).to eq(true)
+      end
+    end
+  end
+end

data/lib/brut/spec_support/handler_support.rb

@@ -0,0 +1,7 @@
+require_relative "flash_support"
+require_relative "session_support"
+module Brut::SpecSupport::HandlerSupport
+  include Brut::SpecSupport::FlashSupport
+  include Brut::SpecSupport::SessionSupport
+end
+

data/lib/brut/spec_support/matcher.rb

@@ -0,0 +1,9 @@
+module Brut::SpecSupport::Matchers
+end
+require_relative "matchers/have_constraint_violation"
+require_relative "matchers/have_html_attribute"
+require_relative "matchers/be_routing_for"
+require_relative "matchers/be_page_for"
+require_relative "matchers/have_rendered"
+require_relative "matchers/have_returned_http_status"
+require_relative "matchers/be_a_bug"

data/lib/brut/spec_support/matchers/be_a_bug.rb

@@ -0,0 +1,14 @@
+RSpec::Matchers.define :be_a_bug do
+  match(:notify_expectation_failures => true) do |actual|
+    exception = nil
+    begin
+      actual.call
+    rescue => ex
+      exception = ex
+    end
+    expect(exception).not_to eq(nil),"Expected a bug, but no exception was thrown"
+    expect(exception).to be_kind_of(Brut::Framework::Errors::Bug)
+  end
+
+  supports_block_expectations
+end

data/lib/brut/spec_support/matchers/be_page_for.rb

@@ -0,0 +1,14 @@
+RSpec::Matchers.define :be_page_for do |klass|
+  match do |page|
+    meta = page.locator("meta[name='class']")
+    expect(meta).to have_attribute("content", klass.name)
+  end
+  failure_message do |page|
+    meta = page.locator("meta[name='class']")
+    if meta.count == 0
+      "Could not find <meta name='class'> on the page:\n\n#{page.content}"
+    else
+      "Could not find <meta name='class' content='#{klass.name}'>, but found:\n\n#{meta.evaluate('e => e.outerHTML')}"
+    end
+  end
+end

data/lib/brut/spec_support/matchers/be_routing_for.rb

@@ -0,0 +1,11 @@
+RSpec::Matchers.define :be_routing_for do |klass,**args|
+  match do |uri|
+    uri == Brut.container.routing.uri(klass,**args)
+  end
+
+  failure_message do |uri|
+    expected = Brut.container.routing.uri(klass,**args)
+    "Expected route for #{klass}: #{expected}, but got #{uri}"
+  end
+
+end

data/lib/brut/spec_support/matchers/have_constraint_violation.rb

@@ -0,0 +1,56 @@
+RSpec::Matchers.define :have_constraint_violation do |field,key:|
+  match do |form|
+    Brut::SpecSupport::Matchers::HaveConstraintViolation.new(form,field,key).matches?
+  end
+
+  failure_message do |form|
+    analysis = Brut::SpecSupport::Matchers::HaveConstraintViolation.new(form,field,key)
+    if analysis.found_field?
+      "#{field} did not have #{key} as a violation.  These keys were found: #{analysis.keys_on_field_found.map(&:to_s).join(", ")}"
+    else
+      "#{field} had no errors.  These fields DID: #{analysis.fields_found.map(&:to_s).join(", ")}"
+    end
+  end
+
+  failure_message_when_negated do |form|
+    "Found #{key} as a violation on #{field}"
+  end
+end
+
+class Brut::SpecSupport::Matchers::HaveConstraintViolation
+  attr_reader :fields_found
+  attr_reader :keys_on_field_found
+
+  def initialize(form, field, key)
+    if !form.kind_of?(Brut::FrontEnd::Form)
+      raise "#{self.class} only works with forms, not #{form.class}"
+    end
+    @form  = form
+    @field = field.to_s
+    @key   = key.to_s
+
+    @matches             = false
+    @found_field         = false
+    @fields_found        = Set.new
+    @keys_on_field_found = Set.new
+
+    @form.constraint_violations.each do |input_name, constraint_violations|
+      if input_name.to_s == @field
+        @found_field = true
+        constraint_violations.each do |constraint_violation|
+          if constraint_violation.key.to_s == @key
+            @matches = true
+          else
+            @keys_on_field_found << constraint_violation.key.to_s
+          end
+        end
+      else
+        @fields_found << input_name.to_s
+      end
+    end
+  end
+
+  def matches?      = @matches
+  def found_field?  = @found_field
+
+end

data/lib/brut/spec_support/matchers/have_html_attribute.rb

@@ -0,0 +1,69 @@
+RSpec::Matchers.define :have_html_attribute do |attribute|
+  if attribute.kind_of?(Hash)
+    if attribute.keys.length != 1
+      raise "have_html_attribute requires a single hash with a single key, or a single symbol/string. Received #{attribute.keys.length} keys: '#{attribute.keys.map(&:to_s).join(", ")}'"
+    end
+  elsif !attribute.kind_of?(Symbol) && !attribute.kind_of?(String)
+    raise "have_html_attribute requires a single hash with a single key, or a single symbol/string. Received a #{attribute.class}"
+  end
+
+  match do |result|
+    Brut::SpecSupport::Matchers::HaveHTMLAttribute.new(result,attribute).matches?
+  end
+
+  failure_message do |result|
+    Brut::SpecSupport::Matchers::HaveHTMLAttribute.new(result,attribute).error
+  end
+
+  failure_message_when_negated do |result|
+    if attribute.kind_of?(Hash)
+      "Found attribute '#{attribute.keys.first}' with value '#{attribute.values.first}'"
+    else
+      "Found attribute '#{attribute}' when not expecting it #{result.to_html}"
+    end
+  end
+end
+
+class Brut::SpecSupport::Matchers::HaveHTMLAttribute
+
+  attr_reader :error
+
+  def initialize(result, attribute)
+    @error = nil
+    if result.kind_of?(Nokogiri::XML::NodeSet)
+      if result.length > 1
+        @error = "Received #{result.length} matching nodes, when only one should've been returned"
+      elsif result.length == 0
+        @error = "Received no matching nodes to examine"
+      else
+        result = result.first
+      end
+    elsif (!result.kind_of?(Nokogiri::XML::Element))
+      @error = "Received a #{result.class} instead of a NodeSet or Element, as could be returned by `.css(...)`"
+    end
+    if !@error
+      if attribute.kind_of?(Hash)
+        attribute_name  = attribute.keys.first.to_s
+        attribute_value = attribute.values.first.to_s
+      else
+        attribute_name = attribute.to_s
+        attribute_value = :any
+      end
+
+      nokogiri_attribute = result.attribute(attribute_name)
+      if nokogiri_attribute
+        if attribute_value != :any
+          found_value = result.attribute(attribute_name).value
+
+          if found_value != attribute_value
+            @error = "Value for '#{attribute_name}' was '#{found_value}'. Expected '#{attribute_value}'"
+          end
+        end
+      else
+        @error = "Did not find attribute '#{attribute_name}' on element.  Found: #{result.attributes.keys.join(", ")}"
+      end
+    end
+  end
+
+  def matches? = @error.nil?
+end

data/lib/brut/spec_support/matchers/have_rendered.rb

@@ -0,0 +1,20 @@
+RSpec::Matchers.define :have_rendered do
+  match do |result|
+    result.kind_of?(String) || result.kind_of?(Brut::FrontEnd::Templates::HTMLSafeString)
+  end
+
+  failure_message do |result|
+    case result
+    in URI => uri
+      "Got a redirect to #{uri} instead of rendering"
+    in Brut::FrontEnd::HttpStatus => http_status
+      "Got an HTTP status of #{http_status} instead of rendering"
+    else
+      "Got an unexpected result: #{result.class} instead of a String"
+    end
+  end
+  failure_message_when_negated do |result|
+    "Result was rendered HTML instead of something else"
+  end
+
+end

data/lib/brut/spec_support/matchers/have_returned_http_status.rb

@@ -0,0 +1,27 @@
+RSpec::Matchers.define :have_returned_http_status do |http_status|
+  match do |result|
+    case result
+    in URI => uri
+      http_status == 302
+    in Brut::FrontEnd::HttpStatus => result_http_status
+      http_status == result_http_status.to_i
+    else
+      http_status == 200
+    end
+  end
+
+  failure_message do |result|
+    case result
+    in URI => uri
+      "Got a redirect (302) instead of a #{http_status}"
+    in Brut::FrontEnd::HttpStatus => result_http_status
+      "Got a #{result_http_status} instead of a #{http_status}"
+    else
+      "Got a render (200) instead of a #{http_status}"
+    end
+  end
+  failure_message_when_negated do |result|
+    "Result was rendered HTML instead of something else"
+  end
+
+end

data/lib/brut/spec_support/session_support.rb

@@ -0,0 +1,3 @@
+module Brut::SpecSupport::SessionSupport
+  def empty_session = Brut.container.session_class.new(rack_session: {})
+end

data/lib/brut/spec_support.rb

@@ -0,0 +1,12 @@
+# Convention here is different. We don't want to autoload
+# a lot of stuff, since RSpec pollutes the Object namespace.
+# Instead, we'll require that these files are required explicitly
+module Brut
+  module SpecSupport
+  end
+end
+require_relative "spec_support/matcher"
+require_relative "spec_support/component_support"
+require_relative "spec_support/handler_support"
+require_relative "spec_support/general_support"
+require_relative "factory_bot"

data/lib/brut/version.rb

@@ -0,0 +1,3 @@
+module Brut
+  VERSION = "0.0.1"
+end

data/lib/brut.rb

@@ -0,0 +1,38 @@
+require_relative "brut/framework"
+
+# Convention is as follows:
+#
+# * singluar thing is a class, the base class of others  being used, e.g. the base page is called Brut::Page
+#   (e.g. and not Brut::Pages::Base).
+module Brut
+  module FrontEnd
+    autoload(:AssetMetadata, "brut/front_end/asset_metadata")
+    autoload(:Component, "brut/front_end/component")
+    autoload(:Components, "brut/front_end/component")
+    autoload(:Download, "brut/front_end/download")
+    autoload(:Flash, "brut/front_end/flash")
+    autoload(:Form, "brut/front_end/form")
+    autoload(:Handler, "brut/front_end/handler")
+    autoload(:Handlers, "brut/front_end/handler")
+    autoload(:HandlingResults, "brut/front_end/handling_results")
+    autoload(:HttpMethod, "brut/front_end/http_method")
+    autoload(:HttpStatus, "brut/front_end/http_status")
+    autoload(:Middleware, "brut/front_end/middleware")
+    autoload(:Middlewares, "brut/front_end/middleware")
+    autoload(:Page, "brut/front_end/page")
+    autoload(:RequestContext, "brut/front_end/request_context")
+    autoload(:RouteHook, "brut/front_end/route_hook")
+    autoload(:RouteHooks, "brut/front_end/route_hook")
+    autoload(:Routing, "brut/front_end/routing")
+    autoload(:Session, "brut/front_end/session")
+  end
+  module BackEnd
+    autoload(:Result, "brut/back_end/result")
+    autoload(:Validators, "brut/back_end/validator")
+  end
+  # DO NOT autoload(:CLI) - that is intended to be require-able on its own
+  autoload(:I18n, "brut/i18n")
+  autoload(:Instrumentation,"brut/instrumentation")
+  autoload(:SinatraHelpers, "brut/sinatra_helpers")
+end
+require "sequel/plugins"

data/lib/sequel/extensions/brut_instrumentation.rb

@@ -0,0 +1,37 @@
+module Sequel
+  module Extensions
+    module BrutInstrumentation
+      class Event < Brut::Instrumentation::Event
+        def initialize(operation:,sql:nil)
+          super(category: "sequel", name: operation, details: { sql: sql })
+        end
+      end
+      def execute(sql, opts = Sequel::OPTS, &block)
+        Brut.container.instrumentation.instrument(Event.new(operation: "execute", sql: sql)) do
+          super
+        end
+      end
+      def execute_dui(sql, opts = Sequel::OPTS, &block)
+        Brut.container.instrumentation.instrument(Event.new(operation: "execute_dui", sql: sql)) do
+          super
+        end
+      end
+      def execute_insert(sql, opts = Sequel::OPTS, &block)
+        Brut.container.instrumentation.instrument(Event.new(operation: "execute_insert", sql: sql)) do
+          super
+        end
+      end
+      def insert_select(*values)
+        Brut.container.instrumentation.instrument(Event.new(operation: "insert_select", sql: values)) do
+          super
+        end
+      end
+      def returning_fetch_rows(sql,&block)
+        Brut.container.instrumentation.instrument(Event.new(operation: "returning_fetch_rows", sql: sql)) do
+          super
+        end
+      end
+    end
+  end
+  Sequel::Dataset.register_extension(:brut_instrumentation, Sequel::Extensions::BrutInstrumentation)
+end

data/lib/sequel/extensions/brut_migrations.rb

@@ -0,0 +1,98 @@
+module Sequel
+  module Extensions
+    # Enhancements to migrations to encourage better practices and reduce boilerplate.
+    #
+    # * If no primary key is specified, a primary key column named :id of type :int will be created
+    # * If no created_at is specified, a column name created_at of type timestamptz is created
+    # * create_table requires a comment: field
+    # * create_table accepts an external_id: true option that will create a unique citext called "external_id"
+    # * columns are non-null by default
+    # * foreign keys are non-null and an index is created
+    # * the `key` method allows specifying keys aka creating a unique constraint
+    module BrutMigrations
+      def create_table(*args)
+        super
+
+        if args.last.is_a?(Hash)
+          if args.last[:comment]
+            run %{
+              comment on table #{args.first} is #{literal args.last[:comment]}
+            }
+          else
+            raise ArgumentError, "Table #{args.first} must have a comment"
+          end
+          if args.last[:external_id]
+            add_column args.first, :external_id, :citext, unique: true
+          end
+        end
+      end
+
+      def add_key(fields)
+        add_index fields, unique: true
+      end
+
+      def add_column(table,*args)
+        options = args.last
+        if options.is_a?(Hash)
+          if !options.key?(:null)
+            options[:null] = false
+          end
+        end
+        super(table,*args)
+      end
+
+      def create_table_from_generator(name, generator, options)
+        if name != "schema_migrations"
+          if generator.columns.none? { |column| column[:primary_key] }
+            generator.primary_key :id
+          end
+          if generator.columns.none? { |column| column[:name].to_s == "created_at" }
+            generator.column :created_at, :timestamptz, null: false
+          end
+          generator.columns.each do |column|
+            if !column.key?(:null)
+              column[:null] = false
+            end
+            if column.key?(:table)
+              if !column.key?(:index)
+                column[:index] = true
+                generator.index(column[:name])
+              end
+            end
+          end
+        end
+        super
+      end
+    end
+  end
+end
+Sequel::Database.register_extension(:brut_migrations) do |db|
+  db.extend Sequel::Extensions::BrutMigrations
+  class ::Sequel::Schema::CreateTableGenerator
+    def key(fields)
+      index fields, unique: true
+    end
+  end
+  class ::Sequel::Schema::AlterTableGenerator
+    def add_column_with_additions(name, type, opts={})
+      if !opts.key?(:null)
+        opts[:null] = false
+      end
+      add_column_base(name,type,opts)
+    end
+    alias_method :add_column_base, :add_column
+    alias_method :add_column, :add_column_with_additions
+
+    def add_foreign_key_with_additions(name, table, opts={})
+      if !opts.key?(:index)
+        opts[:index] = true
+      end
+      if !opts.key?(:null)
+        opts[:null] = false
+      end
+      add_foreign_key_base(name, table, opts)
+    end
+    alias_method :add_foreign_key_base, :add_foreign_key
+    alias_method :add_foreign_key, :add_foreign_key_with_additions
+  end
+end

data/lib/sequel/plugins/created_at.rb

@@ -0,0 +1,14 @@
+module Sequel
+  module Plugins
+    module CreatedAt
+      module InstanceMethods
+        def before_save
+          if self.created_at.nil?
+            self.created_at = Time.now
+          end
+          super
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/external_id.rb

@@ -0,0 +1,45 @@
+module Sequel
+  module Plugins
+    module ExternalId
+      def self.apply(model,*args,&block)
+        @global_prefix = (args.first || {})[:global_prefix]
+      end
+
+      module ClassMethods
+        attr_reader :global_prefix
+        def has_external_id(prefix)
+          global_prefix = find_global_prefix
+          @external_id_prefix = RichString.new("#{global_prefix}#{prefix}").to_s_or_nil
+        end
+
+        def external_id_prefix = @external_id_prefix
+
+        def find_global_prefix(receiver=self)
+          if receiver.respond_to?(:global_prefix)
+            if receiver.global_prefix.nil?
+              receiver.ancestors.select { |ancestor| ancestor != receiver }.map { |ancestor|
+                self.find_global_prefix(ancestor)
+              }.compact.first
+            else
+              receiver.global_prefix
+            end
+          else
+            nil
+          end
+        end
+      end
+
+      module InstanceMethods
+        def before_save
+          if self.class.external_id_prefix
+            if self.external_id.nil?
+              random_hex = SecureRandom.hex
+              self.external_id = "#{self.class.external_id_prefix}_#{random_hex}"
+            end
+          end
+          super
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/find_bang.rb

@@ -0,0 +1,13 @@
+module Sequel
+  module Plugins
+    module FindBang
+      module ClassMethods
+        def find!(**args)
+          self.first!(**args)
+        rescue Sequel::NoMatchingRow => ex
+          raise Sequel::NoMatchingRow.new(ex.message + "; #{args.inspect}")
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins.rb

@@ -0,0 +1,3 @@
+require_relative "plugins/external_id"
+require_relative "plugins/find_bang"
+require_relative "plugins/created_at"