vident-phlex 1.0.2 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 685f521dd022b3123897a08683295cb84787192a4aabecbd3927843a43d6c668
-  data.tar.gz: d25cfb1546470d6736b869d0ed54f310fef6e72dc9ed3018265bb4869dddd713
+  metadata.gz: 6fd97e08c66d8473338aded609cf45f63d982dddc72e376a598218a5224139c5
+  data.tar.gz: 15db0bb5c243e378327792710e491b49c93ab185a0286730e1420d8eae0de2e0
 SHA512:
-  metadata.gz: 16be0de4f984e20dc00184a79af7eb3519713c0bee72cae4e7d768434d77cfd6c4aef1241c71a15008634f47b4016b3ec40d7df216f3980880eb261802953e5e
-  data.tar.gz: 13a4a6bfdde8e2f998a46af8cc5084cc5acc388489cbb46784db850b2c346244e3c726acb150eba7639abec0d6e73d1e7e7a5effd33cc80426eecd255d8d9682
+  metadata.gz: e53d2df34d5720dbd801139e0326bc2837b6af70d4a6ef6a3bbe6b718c8021275931a5adae8b1ce409063aec68c9f286af5aa1ba434e91ca97dc812331506f73
+  data.tar.gz: 4ea8a5f6707e92a0340bb8f409d33533eac3cd509e4e4f0e108218d303cbb077e3965ec551c8f0f9a8bcfd4fd73e817b98f336923e02258aaf5d452507b242ba

data/CHANGELOG.md

@@ -6,6 +6,49 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
 
+## [2.0.0] - 2026-04-24
+
+Vident 2.0 is a ground-up rearchitecture of the DSL, attribute resolution, and composition model. The public shape of `stimulus do ... end`, `root_element`, `child_element`, outlets, props, and the `stimulus_*:` prop/kwarg API is preserved for common cases, but several internals and a handful of edge-case behaviours changed. See `doc/reviews/v1-gotchas.md` for the full list of fixed gotchas; the highlights are below.
+
+### Breaking
+
+- **Namespace consolidation.** The `Vident2::*` namespace used during side-by-side development has been removed. Everything now lives under `Vident::*` directly: `Vident::Component`, `Vident::Capabilities::*`, `Vident::Phlex::HTML`, `Vident::ViewComponent::Base`, `Vident::Stimulus::*` (value classes), `Vident::Internals::*` (DSL/Resolver/Plan). Upgrade path is a `s/Vident2::/Vident::/g` on project code.
+- **Legacy collection classes removed.** `Vident::StimulusAction`, `StimulusTarget`, `StimulusController`, `StimulusValue`, `StimulusParam`, `StimulusOutlet`, `StimulusClass`, and each of their `*Collection` companions (plus `StimulusBuilder`, `StimulusDataAttributeBuilder`, `StimulusAttributeBase`, `StimulusAttributes`, `StimulusAction::Descriptor`) are gone. The 2.0 equivalents live under `Vident::Stimulus::*` (`Action`, `Target`, `Controller`, `Value`, `Param`, `Outlet`, `ClassMap`, `Collection`). `#to_h` now uses **Symbol keys** uniformly; V1 returned String keys for some primitives.
+- **`child_element` strictness.** Passing both `stimulus_<singular>:` and `stimulus_<plural>:` kwargs now raises `ArgumentError` (`"mutually exclusive — pass one or the other."`). V1 silently dropped the singular when the plural was an empty array (latent since 1.0.0, see "Fixed" below). Workaround at call sites that relied on the V1 shape: `stimulus_targets: [:input, *control_targets]`.
+- **`stimulus_controllers:` prop appends instead of replacing.** V1 replaced the implied controller when you passed `stimulus_controllers:` at render time; V2 appends, so the root element carries `data-controller="implied extra"`. Migration: if you wanted to *replace*, add `no_stimulus_controller` at the class level.
+- **Outlet DSL procs now resolve.** V1 silently passed a proc through as the outlet selector string, emitting literal `#<Proc:0x...>`. V2 evaluates the proc in the instance binding and emits the returned string. This turns previously broken code into working code, but if you relied on the proc-as-identity string for some reason, you'll now see a different data attribute.
+- **`nil` vs `false` drop rule.** V1 dropped both `nil` and `false` proc returns silently via a `blank?` filter. V2 drops only `nil`; `false` reaches the parser and raises `Vident::ParseError`. Fix: return `nil` (not `false`) to mean "don't emit this entry."
+- **`no_stimulus_controller` + DSL body now raises loudly.** V1 raised a bare `StandardError` at instance init. V2 raises `Vident::DeclarationError` at `stimulus do ... end` time with the offending class name and caller location in the message.
+- **StableId strategy.** Unchanged from 1.0, but reiterated here because it's the biggest gotcha during upgrade. `Vident::StableId` requires an explicit `strategy` and per-request seed — `bin/rails generate vident:install` sets both up correctly.
+
+### Added
+
+- **Fluent action DSL.** Inside `stimulus do ... end`, the singular `action(...)` call returns a chainable builder: `action(:escape).on(:keydown).keyboard("esc").window`, `action(:save).modifier(:prevent, :stop)`, `action(:delete).when { admin? }`. Chain methods: `.on`, `.call_method`, `.modifier`, `.keyboard`, `.window`, `.on_controller`, `.when`.
+- **Kwargs shorthand for actions.** `action :save, on: :click, modifier: [:prevent, :stop], keyboard: "ctrl+s", window: true, on_controller: :admin, call_method: :handle_save, when: -> { ... }` — equivalent to the fluent chain, pick whichever reads better. Unknown kwargs raise `ArgumentError`.
+- **Controller aliases.** `controller "admin/users", as: :admin` inside `stimulus do` declares a short alias; `action(...).on_controller(:admin)` or `action(..., on_controller: :admin)` then routes through it. Unknown alias refs raise `Vident::DeclarationError`. Runtime inputs (`stimulus_actions: [{method: :save, controller: :admin}]`) resolve the same map.
+- **Capability mixin composition.** `Vident::Component` is a composition root that includes twelve focused capability mixins (`Tailwind`, `Declarable`, `Identifiable`, `StimulusDeclaring`, `StimulusParsing`, `StimulusMutation`, `StimulusDraft`, `StimulusDataEmitting`, `ClassListBuilding`, `RootElementRendering`, `ChildElementRendering`, `Inspectable`), plus an opt-in `Caching` mixin (thirteen in total, including Caching). Mixin order mirrors capability dependencies.
+- **Singular DSL primitives.** `value(:name, *, **)`, `param(:name, *, **)`, `outlet(:name, *, **)`, `class_map(:name, *, **)`, `controller(path, as: nil)`, `controllers(*paths)`, `target(:name).when { ... }` — full set of singular entry points alongside the plural forms.
+- **Draft → Plan seal pattern.** Internal: `after_component_initialize` mutators (e.g. `add_stimulus_actions`) still work against a mutable Draft; the Draft seals into an immutable Plan once rendering begins. Prevents the V1 "mutator silently ignored post-render" class of bug.
+- **Phase-split proc resolution.** DSL procs are evaluated in two phases: static (after_initialize, no `view_context`) and procs (`before_template` / `before_render`, `view_context`/`helpers` wired). Procs can now call Rails helpers (`number_with_precision`, url helpers, `t`, `l`, etc.) safely — already backported to 1.0.2.
+- `has_stimulus_controller` class method re-enables the implied controller in a subclass after a parent declared `no_stimulus_controller` (#27).
+- `root_element_class_list(extra = nil)` and `root_element_data_attributes` for components rendering through third-party tag helpers instead of `root_element(...)` (#25; V1 names `render_classes` / `stimulus_data_attributes` — see UPGRADING.md §8).
+- Class-level Stimulus builders — `MyComponent.stimulus_target(:x)` etc. — return value objects without a component instance (#18).
+- `Vident::Types::*` — seven named Literal unions for the built-in `stimulus_*:` prop types, reusable from user components (#16).
+- `cache_component(*keys, **options, &block)` on both adapter base classes — fragment-caches the block using the Vident-computed `cache_key` (#13).
+- Shared `Vident::Stimulus::Base` + `Combinable` for the value classes: `with(**overrides)` combinator, canonical `deconstruct_keys` (restores pattern matching — previously shadowed by the `to_h` data-attribute override), and `Action.parse([event, existing_action])` merge form (#28).
+
+### Fixed
+
+- `child_element` no longer silently drops a `stimulus_<singular>:` kwarg when `stimulus_<plural>:` is also passed with an empty array. The V1 helper returned early on an empty-but-truthy plural, losing the singular and emitting no data attribute — latent since 1.0.0, surfaced by call sites like `child_element(:input, stimulus_target: :input, stimulus_targets: control_targets)` where `control_targets` defaulted to `[]`. V2 raises `ArgumentError` on both-set (see Breaking); workaround on 1.x is `stimulus_targets: [:input, *control_targets]` (also works on 2.x).
+- Outlet DSL procs now resolve instead of being treated as identity strings (see Breaking).
+- `add_stimulus_actions([:click, :handle])` now treats the Array as *one* action descriptor (event + method pair) rather than splatting it into two separate `:click` and `:handle` actions. Matches the DSL's `actions [:click, :handle]` semantics — the V1 asymmetry is gone.
+
+### Removed
+
+- `Vident::StimulusAction::Descriptor` typed data class. The V2 equivalent is `Vident::Stimulus::Action` itself — the Hash shape accepted by the DSL (`{event:, method:, controller:, options:, keyboard:, window:}`) parses directly into the value class now. Callers that instantiated `Descriptor` explicitly should swap to `Vident::Stimulus::Action.parse(hash, implied: ...)` or just pass the Hash.
+- Legacy top-level requires like `require "vident/stimulus_action"`. The main `require "vident"` loads the whole surface; deep requires for individual value classes still work (`require "vident/stimulus/action"`) but are no longer the documented path.
+
+
 ## [1.0.2] - 2026-04-21
 
 ### Changed

data/README.md

@@ -79,9 +79,13 @@ class ButtonComponent < Vident::ViewComponent::Base
   
   # Configure Stimulus integration
   stimulus do
-    # Setup actions, including with proc to evaluate on instance 
-    actions [:click, :handle_click], 
-            -> { [stimulus_scoped_event(:my_custom_event), :handle_this] if should_handle_this? }
+    # Fluent action DSL: reads left-to-right as "the handle_click method fires on the click event".
+    action(:handle_click).on(:click)
+    # Kwargs shorthand — same result, pick whichever reads better:
+    action :handle_submit, on: :submit, modifier: [:prevent, :stop]
+    # Proc for conditional / cross-component wiring, evaluated in the instance at render time.
+    action(-> { [stimulus_scoped_event(:my_custom_event), :handle_this] if should_handle_this? })
+
     # Map the clicked_count prop as a Stimulus value
     values_from_props :clicked_count
     # Dynamic values using procs (evaluated in component context)
@@ -178,7 +182,7 @@ Use the component in your views:
 <%= render ButtonComponent.new(text: "Cancel", url: "/home", style: :secondary) %>
 
 <!-- Override things -->
-<%= render ButtonComponent.new(text: "Cancel", url: "/home" classes: "bg-red-900", html_options: {role: "button"}) %>
+<%= render ButtonComponent.new(text: "Cancel", url: "/home", classes: "bg-red-900", html_options: {role: "button"}) %>
 ```
 
 The rendered HTML includes all Stimulus data attributes:
@@ -227,7 +231,7 @@ class CardComponent < Vident::ViewComponent::Base
   # Property with validation
   prop :size, _Union(:small, :medium, :large), default: :medium
   
-  # Boolean property (creates predicate method)
+  # Boolean property (pass `predicate: :public` to also generate a `?` method)
   prop :featured, _Boolean, default: false
 end
 ```
@@ -271,7 +275,7 @@ The `root_element` helper method renders your component's root element with all
 ```ruby
 # In your component class
 def root_element_classes
-  ["card", featured? ? "card-featured" : nil]
+  ["card", @featured ? "card-featured" : nil]
 end
 
 private
@@ -362,17 +366,41 @@ class ToggleComponent < Vident::ViewComponent::Base
 end
 ```
 
-**Action modifiers** — the Array form `[:click, :method]` handles the common case. For Stimulus's modifier syntax (`:once`/`:prevent`/`:stop`/`:passive`/`:"!passive"`/`:capture`/`:self`, keyboard filters, `@window`), pass a Hash or a `Vident::StimulusAction::Descriptor`:
+**Action modifiers — fluent DSL.** Singular `action(...)` returns a builder you chain with event, modifier, keyboard, and window setters. Kwargs shorthand is equivalent:
+
+```ruby
+stimulus do
+  action(:submit).on(:click).modifier(:once, :prevent)          # click:once:prevent->implied#submit
+  action(:on_key).on(:keydown).keyboard("ctrl+a")               # keydown.ctrl+a->implied#onKey
+  action(:on_resize).on(:resize).window                         # resize@window->implied#onResize
+
+  # kwargs shorthand — same result:
+  action :submit,     on: :click,   modifier: [:once, :prevent]
+  action :on_key,     on: :keydown, keyboard: "ctrl+a"
+  action :on_resize,  on: :resize,  window: true
+  action :save,       on: :click,   call_method: :handle_save
+
+  # conditional inclusion via `.when` / `when:`:
+  action(:delete).when { admin? }
+end
+```
+
+Chain methods: `.on`, `.call_method`, `.modifier`, `.keyboard`, `.window`, `.on_controller`, `.when`. Recognised kwargs: `on:`, `call_method:`, `modifier:` (Symbol or Array), `keyboard:`, `window:`, `on_controller:`, `when:`. Unknown kwargs or modifier symbols raise `ArgumentError`.
+
+**Controller aliases.** Declare a short alias with `controller "path", as: :sym`, then reference it from action entries via the fluent `.on_controller(:sym)` or the `on_controller: :sym` kwarg:
 
 ```ruby
-actions({event: :click,   method: :submit, options: [:once, :prevent]})
-actions({event: :keydown, method: :on_key, keyboard: "ctrl+a"})
-actions({event: :resize,  method: :on_resize, window: true})
-# or, if you want a typed, passable object:
-actions Vident::StimulusAction::Descriptor.new(event: :click, method: :save, options: [:prevent])
+stimulus do
+  controller "admin/users", as: :admin
+
+  action(:save).on(:click).on_controller(:admin)     # click->admin--users#save
+  action :save, on: :click, on_controller: :admin    # same, kwargs form
+end
 ```
 
-Unknown option symbols raise `ArgumentError` at attribute construction, not at render.
+Unknown aliases raise `Vident::DeclarationError` at render time.
+
+**Legacy Hash form.** Still accepted for compat — `actions({event: :click, method: :submit, options: [:once, :prevent]})` parses the same way. The Hash descriptor is folded directly into `Vident::Stimulus::Action` — pass a Hash and it is parsed in place. Accepted keys: `method:`, `event:`, `controller:`, `options:`, `keyboard:`, `window:`.
 
 ### Dynamic Values and Classes with Procs
 
@@ -489,14 +517,14 @@ class MyComponent < Vident::ViewComponent::Base
     # This would generate: "my-component:dataLoaded"
     puts stimulus_scoped_event(:data_loaded)
     
-    # For window events, this generates: "my-component:dataLoaded@window" 
+    # For window events, this generates: :"my-component:dataLoaded@window" 
     puts stimulus_scoped_event_on_window(:data_loaded)
   end
 end
 
 # Available as both class and instance methods:
-MyComponent.stimulus_scoped_event(:data_loaded)      # => "my-component:dataLoaded"
-MyComponent.new.stimulus_scoped_event(:data_loaded)  # => "my-component:dataLoaded"
+MyComponent.stimulus_scoped_event(:data_loaded)      # => :"my-component:dataLoaded"
+MyComponent.new.stimulus_scoped_event(:data_loaded)  # => :"my-component:dataLoaded"
 ```
 
 This is useful for:
@@ -532,7 +560,7 @@ class CustomComponent < Vident::ViewComponent::Base
 end
 ```
 
-All stimulus props accept Symbol paths as well as Strings (e.g. `stimulus_controllers: [:custom, :"admin/users"]`). `stimulus_values:` and `stimulus_classes:` additionally accept Array entries (for cross-controller: `[["admin/users", :name, "value"]]`) and pre-built `StimulusValue`/`StimulusValueCollection` / `StimulusClass`/`StimulusClassCollection` instances, so you can compose attribute sets outside the component and pass them in.
+All stimulus props accept Symbol paths as well as Strings (e.g. `stimulus_controllers: [:custom, :"admin/users"]`). `stimulus_values:` and `stimulus_classes:` additionally accept Array entries (for cross-controller: `[["admin/users", :name, "value"]]`) and pre-built `Vident::Stimulus::Value` / `Vident::Stimulus::ClassMap` instances, so you can compose attribute sets outside the component and pass them in.
 
 or you can use tag helpers to generate HTML with Stimulus attributes:
 

data/lib/vident/phlex/html.rb

@@ -1,83 +1,86 @@
 # frozen_string_literal: true
 
+require "set"
+
 module Vident
   module Phlex
     class HTML < ::Phlex::HTML
-      include Vident::Component
+      include ::Vident::Component
 
-      STANDARD_ELEMENTS = [:a, :abbr, :address, :article, :aside, :b, :bdi, :bdo, :blockquote, :body, :button, :caption, :cite, :code, :colgroup, :data, :datalist, :dd, :del, :details, :dfn, :dialog, :div, :dl, :dt, :em, :fieldset, :figcaption, :figure, :footer, :form, :g, :h1, :h2, :h3, :h4, :h5, :h6, :head, :header, :hgroup, :html, :i, :iframe, :ins, :kbd, :label, :legend, :li, :main, :map, :mark, :menuitem, :meter, :nav, :noscript, :object, :ol, :optgroup, :option, :output, :p, :path, :picture, :pre, :progress, :q, :rp, :rt, :ruby, :s, :samp, :script, :section, :select, :slot, :small, :span, :strong, :style, :sub, :summary, :sup, :svg, :table, :tbody, :td, :template_tag, :textarea, :tfoot, :th, :thead, :time, :title, :tr, :u, :ul, :video, :wbr].freeze
-      VOID_ELEMENTS = [:area, :br, :embed, :hr, :img, :input, :link, :meta, :param, :source, :track, :col].freeze
+      STANDARD_ELEMENTS = %i[
+        a abbr address article aside b bdi bdo blockquote body button caption
+        cite code colgroup data datalist dd del details dfn dialog div dl dt
+        em fieldset figcaption figure footer form g h1 h2 h3 h4 h5 h6 head
+        header hgroup html i iframe ins kbd label legend li main map mark
+        menuitem meter nav noscript object ol optgroup option output p path
+        picture pre progress q rp rt ruby s samp script section select slot
+        small span strong style sub summary sup svg table tbody td template_tag
+        textarea tfoot th thead time title tr u ul video wbr
+      ].freeze
+      VOID_ELEMENTS = %i[area br embed hr img input link meta param source track col].freeze
       VALID_TAGS = Set[*(STANDARD_ELEMENTS + VOID_ELEMENTS)].freeze
 
       class << self
+        # Walks caller_locations to skip the `inherited` frame itself.
         def inherited(subclass)
-          subclass.component_source_file_path = caller_locations(1, 10).reject { |l| l.label == "inherited" }[0].path
+          loc = caller_locations(1, 10).reject { |l| l.label == "inherited" }[0]
+          subclass.component_source_file_path = loc&.path
           super
         end
 
         attr_accessor :component_source_file_path
 
-        # Caching support
         def cache_component_modified_time
           path = component_source_file_path
-          raise StandardError, "No component source file exists #{path}" unless path && ::File.exist?(path)
+          raise ::Vident::ConfigurationError, "No component source file exists #{path}" unless path && ::File.exist?(path)
           ::File.mtime(path).to_i.to_s
         end
+      end
+
+      # DSL procs stay unresolved until `helpers` is wired; resolve them here.
+      def before_template
+        resolve_stimulus_attributes_at_render_time
+        super
+      end
 
-        # Include the matching `Phlex::Rails::Helpers::<CamelCase>` module for
-        # each Rails helper name. Replaces `helpers.foo(...)` with bare `foo(...)`
-        # calls via phlex-rails' adapter macros.
-        #
-        #   class Card < Vident::Phlex::HTML
-        #     phlex_helpers :number_with_precision, :t, :l
-        #   end
-        def phlex_helpers(*helper_names)
-          helper_names.each do |name|
-            mod_name = name.to_s.camelize
-            mod = begin
-              ::Phlex::Rails::Helpers.const_get(mod_name)
-            rescue NameError
-              raise ArgumentError, "No Phlex::Rails::Helpers::#{mod_name} adapter. See https://www.phlex.fun/rails/helpers for the available list."
-            end
-            include(mod)
-          end
+      # Fragment-cache this component's render using its Vident-computed
+      # `cache_key`. Delegates to Phlex's `cache(...)`; pass extra positional
+      # keys to invalidate on state not captured by `with_cache_key`.
+      def cache_component(*extra_keys, **options, &block)
+        unless respond_to?(:cacheable?) && cacheable?
+          raise ::Vident::ConfigurationError,
+            "#{self.class.name} is not cacheable — `include Vident::Caching` and declare `with_cache_key` first."
         end
+        cache([cache_key, *extra_keys], **options, &block)
       end
 
-      # Helper to create the main element
+      # Capture block first so children can mutate this Draft before it seals (outlet-host pattern).
       def root_element(**overrides, &block)
         tag_type = root_element_tag_type
         check_valid_html_tag!(tag_type)
-        # Evaluate block first so DSL methods run before outer tag options are computed.
-        if block_given?
+        if block
           content = capture(self, &block).html_safe
-          options = resolve_root_element_attributes_before_render(overrides)
+          options = build_root_element_attributes(overrides)
           send(tag_type, **options) { content }
         else
-          send(tag_type, **resolve_root_element_attributes_before_render(overrides))
+          options = build_root_element_attributes(overrides)
+          send(tag_type, **options)
         end
       end
 
-      # Phlex lifecycle hook: resolve stimulus DSL procs now that the view
-      # context is wired (so `helpers` / `view_context` work inside them).
-      def before_template(&)
-        resolve_stimulus_attributes_at_render_time
-        super
-      end
-
       private
 
       def check_valid_html_tag!(tag_name)
-        unless VALID_TAGS.include?(tag_name)
-          raise ArgumentError, "Unsupported HTML tag name #{tag_name}. Valid tags are: #{VALID_TAGS.to_a.join(", ")}"
-        end
+        return if VALID_TAGS.include?(tag_name)
+        raise ArgumentError,
+          "Unsupported HTML tag name #{tag_name}. Valid tags are: #{VALID_TAGS.to_a.join(", ")}"
       end
 
-      def generate_child_element(tag_type, stimulus_data_attributes, options, &block)
+      def generate_child_element(tag_name, stimulus_data_attributes, options, &block)
+        check_valid_html_tag!(tag_name)
         options[:data] ||= {}
         options[:data].merge!(stimulus_data_attributes)
-        check_valid_html_tag!(tag_type)
-        send(tag_type, **options, &block)
+        send(tag_name, **options, &block)
       end
     end
   end

data/lib/vident/phlex.rb

@@ -1,6 +1,7 @@
-require "vident/phlex/version"
+# frozen_string_literal: true
+
+require "phlex"
 require "vident/phlex/html"
-require "vident/phlex/engine" if defined?(Rails)
 
 module Vident
   module Phlex

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vident-phlex
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 2.0.0
 platform: ruby
 authors:
 - Stephen Ierodiaconou
@@ -55,14 +55,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.2
+        version: 2.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.2
+        version: 2.0.0
 - !ruby/object:Gem::Dependency
   name: phlex
   requirement: !ruby/object:Gem::Requirement
@@ -114,9 +114,7 @@ files:
 - LICENSE.txt
 - README.md
 - lib/vident/phlex.rb
-- lib/vident/phlex/engine.rb
 - lib/vident/phlex/html.rb
-- lib/vident/phlex/version.rb
 homepage: https://github.com/stevegeek/vident
 licenses:
 - MIT

data/lib/vident/phlex/engine.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Vident
-  module Phlex
-    class Engine < ::Rails::Engine
-      lib_path = File.expand_path("../../../../lib/", __FILE__)
-      config.autoload_paths << lib_path
-      config.eager_load_paths << lib_path
-
-      config.before_initialize do
-        Rails.autoloaders.each do |autoloader|
-          autoloader.inflector.inflect(
-            "html" => "HTML",
-            "version" => "VERSION"
-          )
-        end
-      end
-    end
-  end
-end

data/lib/vident/phlex/version.rb

@@ -1,5 +0,0 @@
-module Vident
-  module Phlex
-    VERSION = Vident::VERSION
-  end
-end