taksi 0.1.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f068520d9474471f8de3dd72b934a8416da6acfeadfda8b6ccf6c943222ea15
-  data.tar.gz: 0ac983ba246c7a12f7c44c2b51852f47b5d2568a78b7a351e798d4ff9af024e2
+  metadata.gz: e57c4a5876a120b859b3642f790bf13d7f45a691ca74e2a3967d094589b2605a
+  data.tar.gz: da96e2c711489b11c4d24f88cb8e3ae738774c484772e3a9c5e0106ab13f5573
 SHA512:
-  metadata.gz: 9bab30c33f37c2aceb47b04d6c249030f71a2fd16762569e604c371bba86322a822575d84330e7d69143b46bd3096b5bf5752e79cedd8c7f3d8ead7fe30fc53a
-  data.tar.gz: 3ef033f144438741084fc36291923cd04a001fb802b9d5091fea7f4fc43169da7d987e14d68954627890134b642daeba0e84523330d0b0dd530080a9cfb5f8e2
+  metadata.gz: 1f52db226be934f1c70c127f2c75b105c1cdc65efd8443a76e338cb62769c95f2511e3b282521d753d6e34cc8791282889b7ef8d05bc471e3ad6b0fc87f8c316
+  data.tar.gz: 229d3fbd97e55eaa3e70a3dd735e2e3b6f4947d9b3b91a962d73a2680c8bccd0c9d04af2a63bff3fcd37810519e65af3c52adb37111c801b8098d2ebdec793e9

data/README.md

@@ -0,0 +1,115 @@
+# Taksi [![Gem Version](https://badge.fury.io/rb/taksi.svg)](https://badge.fury.io/rb/taksi) [![CI](https://github.com/taksi-br/taksi-ruby/actions/workflows/ci.yml/badge.svg)](https://github.com/taksi-br/taksi-ruby/actions/workflows/ci.yml) [![Codacy Badge](https://app.codacy.com/project/badge/Coverage/c3b7b1b64129408a946ce2c99a5b2706)](https://app.codacy.com/gh/taksi-br/taksi-ruby/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_coverage)
+
+Application framework to build a backend driven UI in ruby.
+
+## Considerations
+
+This repository are in its **very early days** and **not ready for production** yet. If you want to help or understand what it is, get a look over our inspirations on the links below:
+  - https://medium.com/movile-tech/backend-driven-development-ios-d1c726f2913b
+  - https://engineering.q42.nl/server-driven-ui-at-primephonic/
+  - https://www.youtube.com/watch?v=vuCfKjOwZdU
+
+Also, we're working in create a protocol documentation to explain the comunication details between frontend and backend.
+
+## Usage
+
+In Taksi, every interface are composed by 1 to many components, those components are feed by data provided from the interface definition.
+
+Defining a new component:
+
+```ruby
+class Components::Users::ProfileResume
+  include Taksi::Component.new('users/profile_resume')
+
+  content do
+    name Taksi::Dynamic
+    profile_kind Taksi::Static, 'resume'
+
+    details do
+      age Taksi::Dynamic
+      email Taksi::Dynamic
+    end
+  end
+end
+```
+
+Defining a new interface (in this example a interface interface):
+
+```ruby
+class Interfaces::UserProfile
+  include Taksi::Interface.new('user_profile')
+
+  add Components::Users::ProfileResume, with: :profile_data
+
+  attr_accessor :user
+
+  def profile_data
+    {
+      name: user.name,
+      details: {
+        age: user.age,
+        email: user.email,
+      }
+    }
+  end
+end
+```
+
+From those definitions you can set up the skeleton or strip the data:
+
+```ruby
+user_profile = Interfaces::UserProfile.new
+user_profile.skeleton.as_json
+```
+
+Which provide us:
+
+```json
+{
+  "components": [
+    {
+      "name": "users/profile_resume",
+      "identifier": "component$0",
+      "requires_data": true,
+      "content": {
+        "name": null,
+        "profile_kind": "resume",
+        "details": {
+          "age": null,
+          "email": null
+        }
+      }
+    }
+  ]
+}
+```
+
+Then, you can strip the data off:
+
+```ruby
+user_profile.user = User.find(logged_user_id)
+user_profile.data.as_json
+```
+
+```json
+{
+  "interface_data": [
+    {
+      "identifier": "component$0",
+      "content": {
+        "name": "Israel Trindade",
+        "details": {
+          "age": 29,
+          "email": "irto@outlook.com",
+        }
+      }
+    }
+  ]
+}
+```
+
+## Supported Ruby versions
+
+This library officially supports the following Ruby versions:
+
+  * MRI `>= 2.7`

data/lib/taksi/component.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Taksi
+  # A custom module to turn a class into a component on taksi protocol
+  #
+  # ```ruby
+  #   class CustomComponent
+  #     include Taksi::Component.new('customs/component_name')
+  #
+  #     content do
+  #       field_name Taksi::Static
+  #     end
+  #   end
+  # ```
+  #
+  class Component < ::Module
+    attr_reader :identifier
+
+    def initialize(identifier)
+      @identifier = identifier
+      super()
+    end
+
+    def included(klass)
+      klass.extend(ClassMethods)
+      klass.include(InstanceMethods)
+
+      klass.definition = self
+    end
+
+    module ClassMethods
+      attr_reader :content_builder
+
+      def definition=(component_definition)
+        @component_definition = component_definition
+      end
+
+      def identifier
+        @component_definition.identifier
+      end
+
+      def content(&block)
+        @content_builder = block
+        self
+      end
+    end
+
+    module InstanceMethods
+      attr_reader :interface_definition, :datasource, :skeleton
+
+      def initialize(interface_definition, with: nil)
+        @interface_definition = interface_definition
+        @datasource = with
+        @skeleton = @interface_definition.skeleton.create_component(self.class.identifier,
+                                                                    &self.class.content_builder)
+        super()
+      end
+
+      def id
+        @skeleton.id
+      end
+
+      def content_for(interface)
+        data = interface.send(datasource)
+
+        skeleton.fields.each_with_object({}) do |field, obj|
+          load_data_from_key_to_object(data, field, obj)
+        end
+      end
+
+      private
+
+      def load_data_from_key_to_object(data, field, obj)
+        splitted_full_path = field.key.to_s.split('.')
+        setter_key = splitted_full_path.pop
+        splitted_full_path.shift # remove content root key, as it makes no sense in data object
+
+        relative_object = splitted_full_path.reduce(obj) do |memo, path_part|
+          memo[path_part.to_sym] ||= {}
+        end
+
+        relative_object[setter_key.to_sym] = field.fetch_from(data)
+      end
+    end
+  end
+end

data/lib/taksi/components/field.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Taksi
+  module Components
+    class Field
+      attr_reader :skeleton, :name, :value, :parent
+
+      def initialize(skeleton, name, *args, parent: nil, &block)
+        @skeleton = skeleton
+        @name = name.to_sym
+        @parent = parent
+
+        raise <<~MESSAGE unless args.size.positive? || block_given?
+          You must provide a value or a block definition to build field
+        MESSAGE
+
+        @value = args.shift.new(skeleton, name, *args) if args.size.positive?
+        @nested_fields = []
+
+        instance_exec(&block) if block_given?
+        @defined = true
+      end
+
+      def key
+        return name if parent.nil? || parent.root?
+
+        "#{parent.name}.#{name}"
+      end
+
+      # Fetches the data for in `data` for the current field
+      # @return any
+      def fetch_from(data)
+        return value.as_json if value.static?
+
+        return data[name] if parent.nil? || parent.root?
+
+        parent.fetch_from(data)[name]
+      rescue NoMethodError
+        raise NameError, "Couldn't fetch #{key.inspect} from data: #{data.inspect}"
+      end
+
+      # Turns the field into his json representation
+      # The returned hash is compatible with the skeleton json specification
+      # @return Hash
+      def as_json
+        return {name => @nested_fields.map(&:as_json).inject({}, &:merge)} if nested?
+
+        {name => value.as_json}
+      end
+
+      # Builds up a interator over all fields included nested ones
+      # @returns Enumerable
+      def fields
+        Enumerator.new do |yielder|
+          @nested_fields.each do |field|
+            if field.nested?
+              field.fields.each(&yielder)
+            else
+              yielder << field
+            end
+          end
+        end
+      end
+
+      def nested?
+        @value.nil?
+      end
+
+      def root?
+        @parent.nil?
+      end
+
+      def dynamic?
+        return @nested_fields.any?(&:dynamic?) if @value.nil?
+
+        @value.dynamic?
+      end
+
+      def method_missing(name, *args, &block)
+        return super if @defined
+
+        @nested_fields << self.class.new(skeleton, name, *args, parent: self, &block)
+      end
+
+      def respond_to_missing?(name, *)
+        return super if @defined
+
+        true
+      end
+    end
+  end
+end

data/lib/taksi/components/skeleton.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Taksi
+  module Components
+    class Skeleton
+      attr_reader :parent, :name, :content
+
+      def initialize(parent, name, &block)
+        @parent = parent
+        @name = name
+
+        raise 'To build a component you need to provide a `content` block' unless block_given?
+
+        @content = ::Taksi::Components::Field.new(self, :content, &block)
+      end
+
+      def id
+        parent.id_of(self)
+      end
+
+      def fields
+        content.fields
+      end
+
+      def dynamic?
+        @content.dynamic?
+      end
+
+      def as_json
+        {
+          name: name,
+          identifier: id,
+          requires_data: dynamic?
+        }.tap do |json|
+          json.merge!(content.as_json)
+        end
+      end
+    end
+  end
+end

data/lib/taksi/interface.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Taksi
+  # A custom module that turns a class into a interface on taksi protocol
+  #
+  class Interface < ::Module
+    attr_reader :interface_name, :version_pattern, :alternatives
+
+    # Finds for a interface by its name and the current version
+    # @param name [String]
+    # @param version [String] just like '0.2.1'
+    # @param alternatives: [Array]
+    # @raises`::Taksi::Registry::InterfaceNotFoundError`
+    # @return Class the class of interface
+    def self.find(name, version, alternative: nil)
+      ::Taksi::Registry.find(name, version, alternative)
+    end
+
+    def initialize(name, version_pattern = nil, alternatives: nil)
+      @interface_name = name
+      @version_pattern = ::Gem::Requirement.new(version_pattern)
+      @alternatives = alternatives
+      super()
+    end
+
+    def included(klass)
+      klass.extend(ClassMethods)
+      klass.include(InstanceMethods)
+
+      klass.initiate(self)
+
+      ::Taksi::Registry.add(klass, interface_name)
+    end
+
+    module ClassMethods
+      attr_reader :skeleton
+
+      def find(version, alternative = nil)
+        ::Taksi::Registry.find(@interface_definition.interface_name, version, alternative)
+      end
+
+      def initiate(interface_definition)
+        @components = []
+        @interface_definition = interface_definition
+        @skeleton = ::Taksi::Interfaces::Skeleton.new
+      end
+
+      def add(component_class, with: nil)
+        @components << component_class.new(self, with: with)
+      end
+
+      def components
+        @components.each
+      end
+
+      def version_pattern
+        @interface_definition.version_pattern
+      end
+
+      def alternatives
+        @interface_definition.alternatives
+      end
+    end
+
+    module InstanceMethods
+      def skeleton
+        self.class.skeleton
+      end
+
+      def data
+        self.class.components.map do |component|
+          {
+            identifier: component.id,
+            content: component.content_for(self)
+          }
+        end
+      end
+    end
+  end
+end

data/lib/taksi/interfaces/skeleton.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Taksi
+  module Interfaces
+    class Skeleton
+      class ComponentNotFoundError < StandardError; end
+
+      def initialize
+        @component_skeletons = []
+      end
+
+      def create_component(identifier, &block)
+        ::Taksi::Components::Skeleton.new(self, identifier, &block).tap do |component|
+          add(component)
+        end
+      end
+
+      def add(component_skeleton)
+        @component_skeletons << component_skeleton
+        self
+      end
+
+      def id_of(component)
+        index = @component_skeletons.index(component)
+
+        raise ComponentNotFoundError unless index
+
+        "component$#{index}"
+      end
+
+      def as_json(*)
+        {components: @component_skeletons.map(&:as_json)}
+      end
+    end
+  end
+end

data/lib/taksi/registry.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'forwardable'
 module Taksi
   class Registry
     include ::Singleton
@@ -11,8 +10,8 @@ module Taksi
       def_delegators :instance, :find, :add, :clear!
     end
 
-    class ScreenNotFoundError < ::StandardError; end
-    class ScreenAltenativeNotFoundError < ::StandardError; end
+    class InterfaceNotFoundError < ::StandardError; end
+    class InterfaceAltenativeNotFoundError < ::StandardError; end
 
     def initialize
       clear!
@@ -21,36 +20,36 @@ module Taksi
     def add(klass, name)
       sym_name = name.to_sym
 
-      @screens[sym_name] ||= []
-      @screens[sym_name] << klass
+      @interfaces[sym_name] ||= []
+      @interfaces[sym_name] << klass
     end
 
     def clear!
-      @screens = {}
+      @interfaces = {}
     end
 
     def find(name, version, alternative = nil)
-      screens_from_name = @screens[name.to_sym]
+      interfaces_from_name = @interfaces[name.to_sym]
 
-      raise ScreenNotFoundError if screens_from_name.blank?
+      raise InterfaceNotFoundError if interfaces_from_name.nil?
 
       parsed_version = ::Gem::Version.new(version)
 
-      screen = screens_from_name.find do |screen|
-        next false unless screen.version_pattern.satisfied_by?(parsed_version)
+      found_interface = interfaces_from_name.find do |interface|
+        next false unless interface.version_pattern.satisfied_by?(parsed_version)
 
-        next true if alternative.blank?
+        next true if alternative.nil?
 
-        next true if screen.alternatives.blank?
+        next true if interface.alternatives.nil?
 
-        next true if screen.alternatives.include?(alternative)
+        next true if interface.alternatives.include?(alternative)
 
         false
       end
 
-      raise ScreenNotFoundError if screen.blank?
+      raise InterfaceNotFoundError if found_interface.nil?
 
-      screen
+      found_interface
     end
   end
 end

data/lib/taksi/values/dynamic.rb

@@ -3,27 +3,31 @@
 module Taksi
   module Values
     class Dynamic
-      attr_reader :widget, :name, :content_key
+      attr_reader :component, :name, :field
 
-      def initialize(widget, name, content_key = nil)
-        @widget = widget
+      def initialize(component, name, field = nil)
+        @component = component
         @name = name
-        @content_key = content_key
+        @field = field
       end
 
       def path
-        return content_key if content_key
+        return field if field
 
-        "#{widget.id}.#{name}"
+        "#{component.id}.#{name}"
       end
 
       def as_json
-        {type: 'dynamic', value: path}
+        nil
       end
 
       def dynamic?
         true
       end
+
+      def static?
+        false
+      end
     end
   end
 

data/lib/taksi/values/static.rb

@@ -3,21 +3,25 @@
 module Taksi
   module Values
     class Static
-      attr_reader :widget, :name, :value
+      attr_reader :component, :name, :value
 
-      def initialize(widget, name, value)
-        @widget = widget
+      def initialize(component, name, value)
+        @component = component
         @name = name
         @value = value
       end
 
       def as_json
-        {type: 'static', value: value}
+        value
       end
 
       def dynamic?
         false
       end
+
+      def static?
+        true
+      end
     end
   end
 

data/lib/taksi/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Taksi
-  VERSION = '0.1.0'
+  VERSION = '0.2.2'
 end

data/lib/taksi.rb

@@ -1,20 +1,21 @@
 # frozen_string_literal: true
 
 require 'singleton'
+require 'forwardable'
 
 require 'taksi/version'
 
 require 'taksi/values/dynamic'
 require 'taksi/values/static'
 
-require 'taksi/widget'
-require 'taksi/widgets/skeleton'
-require 'taksi/widgets/content_key'
+require 'taksi/component'
+require 'taksi/components/skeleton'
+require 'taksi/components/field'
 
 require 'taksi/registry'
 
-require 'taksi/screen'
-require 'taksi/screens/skeleton'
+require 'taksi/interface'
+require 'taksi/interfaces/skeleton'
 
 module Taksi
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: taksi
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.2
 platform: ruby
 authors:
 - Israel Trindade
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-07-07 00:00:00.000000000 Z
+date: 2023-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -38,8 +52,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Useful tool to help build a backend over the concept of Backend For Frontend,
-  or backend-driven frontends.
+description: Useful toolset to build a backend over the concept of backend-driven
+  UI (aka. backend for frontend).
 email:
 - irto@outlook.com
 executables: []
@@ -50,15 +64,15 @@ files:
 - README.md
 - Rakefile
 - lib/taksi.rb
+- lib/taksi/component.rb
+- lib/taksi/components/field.rb
+- lib/taksi/components/skeleton.rb
+- lib/taksi/interface.rb
+- lib/taksi/interfaces/skeleton.rb
 - lib/taksi/registry.rb
-- lib/taksi/screen.rb
-- lib/taksi/screens/skeleton.rb
 - lib/taksi/values/dynamic.rb
 - lib/taksi/values/static.rb
 - lib/taksi/version.rb
-- lib/taksi/widget.rb
-- lib/taksi/widgets/content_key.rb
-- lib/taksi/widgets/skeleton.rb
 homepage: 
 licenses: []
 metadata:
@@ -84,5 +98,5 @@ requirements: []
 rubygems_version: 3.3.26
 signing_key: 
 specification_version: 4
-summary: A tool to design backend driver for frontend
+summary: Application framework to build a backend driven UI in ruby
 test_files: []

data/lib/taksi/screen.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module Taksi
-  class Screen < ::Module
-    attr_reader :page_name, :version_pattern, :alternatives
-
-    def self.find(name, version, alternative: nil)
-      ::Taksi::Registry.find(name, version, alternative)
-    end
-
-    def initialize(name, version_pattern = nil, alternatives: nil)
-      @page_name = name
-      @version_pattern = ::Gem::Requirement.new(version_pattern)
-      @alternatives = alternatives
-    end
-
-    def included(klass)
-      klass.extend(ClassMethods)
-      klass.include(InstanceMethods)
-
-      klass.initiate(self)
-
-      ::Taksi::Registry.add(klass, page_name)
-    end
-
-    module ClassMethods
-      attr_reader :widgets, :skeleton
-
-      def find(version, alternative = nil)
-        ::Taksi::Registry.find(page_name, version, alternative)
-      end
-
-      def initiate(screen_definition)
-        @widgets = []
-        @screen_definition = screen_definition
-        @skeleton = ::Taksi::Screens::Skeleton.new
-      end
-
-      def add(widget_class, with: nil)
-        @widgets << widget_class.new(self, with: with)
-      end
-
-      def widgets
-        @widgets.each
-      end
-
-      def version_pattern
-        @screen_definition.version_pattern
-      end
-
-      def alternatives
-        @screen_definition.alternatives
-      end
-    end
-
-    module InstanceMethods
-      def skeleton
-        self.class.skeleton
-      end
-
-      def data
-        self.class.widgets.each_with_object({}) do |widget, obj|
-          obj.merge!(widget.data_for(self).as_json)
-        end
-      end
-    end
-  end
-end

data/lib/taksi/screens/skeleton.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Taksi
-  module Screens
-    class Skeleton
-      class WidgetNotFoundError < StandardError; end
-
-      def initialize
-        @widget_skeletons = []
-      end
-
-      def create_widget(identifier, &block)
-        ::Taksi::Widgets::Skeleton.new(self, identifier, &block).tap do |widget|
-          add(widget)
-        end
-      end
-
-      def add(widget_skeleton)
-        @widget_skeletons << widget_skeleton
-        self
-      end
-
-      def id_of(widget)
-        index = @widget_skeletons.index(widget)
-
-        raise WidgetNotFoundError unless index
-
-        "widget$#{index}"
-      end
-
-      def as_json(*)
-        {widgets: @widget_skeletons.map(&:as_json)}
-      end
-    end
-  end
-end

data/lib/taksi/widget.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module Taksi
-  class Widget < ::Module
-    attr_reader :identifier
-
-    def initialize(identifier)
-      @identifier = identifier
-    end
-
-    def included(klass)
-      klass.extend(ClassMethods)
-      klass.include(InstanceMethods)
-
-      klass.definition = self
-    end
-
-    module ClassMethods
-      attr_reader :content_builder
-
-      def definition=(widget_definition)
-        @widget_definition = widget_definition
-      end
-
-      def identifier
-        @widget_definition.identifier
-      end
-
-      def content(&block)
-        @content_builder = block
-        self
-      end
-    end
-
-    module InstanceMethods
-      attr_reader :page_definition, :datasource, :skeleton
-
-      def initialize(page_definition, with: nil)
-        @page_definition = page_definition
-        @datasource = with
-        @skeleton = @page_definition.skeleton.create_widget(self.class.identifier,
-                                                            &self.class.content_builder)
-      end
-
-      def data_for(page_instance)
-        data = page_instance.send(datasource)
-
-        skeleton.keys.each_with_object({}) do |content_key, obj|
-          next unless content_key.value.dynamic?
-
-          load_data_from_key_to_object(data, content_key, obj)
-        end
-      end
-
-      private
-
-      def load_data_from_key_to_object(data, content_key, obj)
-        splitted_full_path = content_key.value.path.split('.')
-        setter_key = splitted_full_path.pop
-
-        relative_object = splitted_full_path.reduce(obj) do |memo, path_part|
-          memo[path_part] ||= {}
-        end
-
-        relative_object[setter_key] = content_key.fetch_from(data)
-      end
-    end
-  end
-end

data/lib/taksi/widgets/content_key.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module Taksi
-  module Widgets
-    class ContentKey
-      attr_reader :skeleton, :key, :value, :parent
-
-      def initialize(skeleton, key, *args, parent: nil, &block)
-        @skeleton = skeleton
-        @key = key.to_sym
-        @parent = parent
-
-        @value = args.shift.new(skeleton, full_key, *args) if args.size.positive?
-        @nested_keys = []
-
-        instance_exec(&block) if block_given?
-        @defined = true
-      end
-
-      def full_key
-        return key if parent.nil? || parent.root?
-
-        "#{parent.full_key}.#{key}"
-      end
-
-      def fetch_from(data)
-        return data[key] if parent.nil? || parent.root?
-
-        parent.fetch_from(data)[key]
-      rescue NoMethodError
-        raise NameError, "Couldn't fetch #{key.inspect} from data: #{data.inspect}"
-      end
-
-      def as_json
-        return {key => @nested_keys.map(&:as_json).inject({}, &:merge)} if nested?
-
-        {key => value.as_json}
-      end
-
-      def keys
-        Enumerator.new do |yielder|
-          @nested_keys.each do |key|
-            if key.nested?
-              key.keys.each(&yielder)
-            else
-              yielder << key
-            end
-          end
-        end
-      end
-
-      def nested?
-        @value.nil?
-      end
-
-      def root?
-        @parent.nil?
-      end
-
-      def method_missing(name, *args, &block)
-        return super if @defined
-
-        @nested_keys << self.class.new(skeleton, name, *args, parent: self, &block)
-      end
-    end
-  end
-end

data/lib/taksi/widgets/skeleton.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module Taksi
-  module Widgets
-    class Skeleton
-      attr_reader :parent, :identifier, :content
-
-      def initialize(parent, identifier, &block)
-        @parent = parent
-        @identifier = identifier
-
-        @content = ::Taksi::Widgets::ContentKey.new(self, :content, &block)
-      end
-
-      def id
-        parent.id_of(self)
-      end
-
-      def keys
-        content.keys
-      end
-
-      def as_json
-        {identifier: identifier}.tap do |json|
-          json.merge!(content.as_json)
-        end
-      end
-    end
-  end
-end