flexi_view 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b61d39a96b6c62e0ffaefcefb4e495a8b29120c53c995fd16709a819ec56b9d8
+  data.tar.gz: 7873e476bd12b730f6b31638d6302fd0c54318cafa0b6a58df074e3aa83b035a
+SHA512:
+  metadata.gz: e05029dbc061d83c36bc20596085269a795a3fbee69133e7f42d55557e5c20c794bd20db6c3ae3fe19f19dd27357af4c741c93fdfd0d5c2f8a50f4b29952af44
+  data.tar.gz: d2e4f177ba0bea3b277cffe4a1dd3bb1482e267c2c524511755a466879234c66c1a19968589c1bffb57701100431509d9ae39f7d68b3235098bf46314436d98d

data/.rubocop.yml

@@ -0,0 +1,39 @@
+require:
+  - rubocop-rspec
+  - rubocop-factory_bot
+  - rubocop-rake
+
+AllCops:
+  SuggestExtensions: false
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Max: 120
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Lint/ConstantDefinitionInBlock:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-07-07
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Jiren Patel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,471 @@
+# FlexiView Serializer
+
+FlexiView is a flexible Ruby serialization library that eliminates the need for multiple serializer classes by providing dynamic views and namespaces within a single serializer definition.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add flexi_view
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install flexi_view
+```
+
+## Quick Example
+
+```ruby
+class ProductSerializer
+  include FlexiView::Serializer
+
+  attributes :id, :name, :price, :retailer_price
+  one :offer, "OfferSerializer"
+
+  view(:index).fields(:id, :name).association(:offer)
+
+  namespace(:admin) do
+    view(:index).fields(:id, :name, :price, :retailer_price).association(:offer)
+  end
+end
+
+# Usage
+ProductSerializer.new(product).serializable_hash(view: :index)
+ProductSerializer.new(product).serializable_hash(namespace: :admin, view: :index)
+```
+
+## Key Features
+- **Single Serializer, Multiple Views**: Define different output formats in one class
+- **Namespace Support**: Create context-specific serialization (admin, user, mobile, web)
+- **Flexible Attributes**: Simple, conditional, and custom attribute definitions
+- **Association Handling**: Support for both `one` and `many` relationships
+- **Custom Formatters**: Global formatters for consistent data formatting
+- **Meta Information**: Add pagination and other metadata with root key support
+
+## Core Benefits
+1. **Reduced Code Duplication**: No need for separate serializer classes for different views
+2. **BFF Pattern Ready**: Perfect for Backend for Frontend architecture with namespace support
+3. **Clean & Maintainable**: Centralized serialization logic for better organization
+
+## Perfect For
+- API development requiring multiple response formats
+- Backend for Frontend (BFF) implementations
+- Applications with different user roles requiring different data views
+
+## Quick Help
+
+- [Configuration](#Configuration)
+- [Basic Usage](#basic-usage)
+- [Defining Attributes](#defining-attributes)
+- [Custom Formatters](#custom-formatters)
+- [Associations](#associations)
+- [Views](#views)
+- [Namespaces](#namespaces)
+- [Meta Information](#meta-information)
+- [Serialization](#serialization)
+- [Benefits](#benefits)
+- [Examples](#examples)
+
+## Configuration
+
+- How to use different JSON enconder gem.
+
+Default JSON encoder gem is  "json" gem..
+
+```ruby
+require "oj"
+
+FlexiView.json_encoder = Oj
+```
+
+## Basic Usage
+
+To create a serializer, include `FlexiView::Serializer` in your class:
+
+```ruby
+class ProductSerializer
+  include FlexiView::Serializer
+
+  attributes :id, :name, :price
+end
+```
+
+## Defining Attributes
+
+### Simple Attributes
+
+Define basic attributes that will be serialized:
+
+```ruby
+attributes :id, :name, :discount
+```
+
+### Conditional Attributes
+
+Add conditions to attributes using the `if` option:
+
+```ruby
+attributes :price, :retail_price, format: :currency, if: -> { object.available? }
+```
+
+### Custom Attribute Blocks
+
+Define custom attribute logic using blocks:
+
+```ruby
+attribute :profit_margin do |object|
+  "#{object.calculate_profit_margin}%"
+end
+```
+
+### Formatted Attributes
+
+Apply formatters to attributes:
+
+```ruby
+attributes :price, :retail_price, format: :currency
+```
+
+## Custom Formatters
+
+Define custom formatters globally:
+
+```ruby
+FlexiView.formatter :currency do |value, _serializer|
+  "$ #{value.to_f}"
+end
+```
+
+## Associations
+
+### Has One Association
+
+```ruby
+one :offer, "OfferSerializer"
+```
+
+### Has Many Association
+
+```ruby
+many :assets, "AssetSerializer"
+```
+
+### Association with Custom Logic
+
+```ruby
+many :specifications, "SpecificationSerializer" do |product|
+  product.specifications.not_archived
+end
+```
+## Views
+
+Views allow you to define different sets of fields and associations for different contexts.
+
+### Basic View Definition
+
+```ruby
+view(:index).fields(:id, :name, :price).association(:offer).meta(:pagination)
+```
+
+### Multiple Views
+
+```ruby
+view(:index).fields(:id, :name, :price).association(:offer)
+view(:show).fields(:id, :name, :price, :retail_price)
+```
+
+### View with Associations
+
+```ruby
+view(:index).fields(:id, :name).association(:assets, view: :show)
+```
+
+## Namespaces
+
+Namespaces allow you to group views by context (e.g., admin, user, api):
+
+```ruby
+namespace(:admin) do
+  view(:index)
+    .fields(:id, :name, :price, :available_count, :profit_margin)
+    .associations(:specifications, :offer, view: :index)
+end
+```
+
+### Multiple Namespaces
+
+```ruby
+namespace(:admin) do
+  view(:index).fields(:id, :name, :price, :available_count)
+  view(:show).fields(:id, :name, :price, :retail_price, :profit_margin)
+end
+
+namespace(:user) do
+  view(:index).fields(:id, :name, :price)
+  view(:show).fields(:id, :name, :price, :retail_price)
+end
+```
+
+## Meta Information
+
+Add meta information to your serialized output:
+
+```ruby
+meta(:pagination, root_key: "products") do |objects|
+  { count: objects.length, page: options[:page] }
+end
+```
+
+
+The `root_key` parameter specifies which key in the serialized output should contain the meta information.
+
+## Serialization
+
+### Single Object Serialization
+
+```ruby
+# Default serialization (all attributes)
+ProductSerializer.new(Product.objects(1)).serializable_hash
+
+# Using a specific view
+ProductSerializer.new(Product.objects(1)).serializable_hash(view: :index)
+
+# Using namespace and view
+ProductSerializer.new(Product.objects(1)).serializable_hash(namespace: :admin, view: :index)
+```
+
+### Array Serialization
+
+FlexiView can serialize both single objects and arrays of objects:
+
+```ruby
+# Serialize array of products
+ProductSerializer.new(Product.all).serializable_hash(view: :index)
+```
+
+## Benefits
+
+### 1. Single Serializer, Multiple Views
+No need to create separate serializer classes for different views. Define all variations in one place:
+
+```ruby
+class ProductSerializer
+  include FlexiView::Serializer
+
+  attributes :id, :name, :price, :description, :stock
+
+  view(:list).fields(:id, :name, :price)
+  view(:detail).fields(:id, :name, :price, :description, :stock)
+  view(:minimal).fields(:id, :name)
+end
+```
+
+### 2. Easy BFF (Backend for Frontend) Pattern Implementation
+Different namespaces for different frontends:
+
+```ruby
+namespace(:mobile) do
+  view(:list).fields(:id, :name, :price)
+end
+
+namespace(:web) do
+  view(:list).fields(:id, :name, :price, :description)
+end
+
+namespace(:admin) do
+  view(:list).fields(:id, :name, :price, :stock, :created_at)
+end
+```
+
+### 3. Clean and Maintainable Code
+All serialization logic is centralized, making it easier to maintain and understand the different output formats.
+
+## Examples
+
+### Complete Example
+
+```ruby
+# Define formatters
+FlexiView.formatter :currency do |value, _serializer|
+  "$ #{value.to_f}"
+end
+
+class ProductSerializer
+  include FlexiView::Serializer
+
+  attributes :id, :name, :available_count
+  attributes :price, :retail_price, format: :currency, if: -> { object.id == 1 }
+
+  attribute :profit_margin do |object|
+    "#{object.calculate_profile_margin}%"
+  end
+
+  many :specifications, "SpecificationSerializer" do |product|
+    product.specifications.not_archived
+  end
+
+  one :offer, "OfferSerializer"
+
+  meta(:pagination, root_key: "products") do |objects|
+    { count: objects.length, page: options[:page] }
+  end
+
+  # Public views
+  view(:index).fields(:id, :name, :price).association(:offer).meta(:pagination)
+  view(:show).fields(:id, :name, :price, :retail_price)
+
+  # Admin namespace
+  namespace(:admin) do
+    view(:index)
+      .fields(:id, :name, :price, :available_count, :profit_margin)
+      .associations(:specifications, :offer, view: :index)
+  end
+end
+
+class AssetSerializer
+  include FlexiView::Serializer
+
+  attributes :id, :name, :image, :type
+
+  view(:show).fields(:id, :name, :image)
+end
+
+class OfferSerializer
+  include FlexiView::Serializer
+
+  attributes :id, :name, :discount
+  many :assets, "AssetSerializer"
+
+  view(:index).fields(:id, :name).association(:assets, view: :show)
+end
+
+# Usage examples
+product = Product.find(1)
+
+# Default serialization
+ProductSerializer.new(product).serializable_hash # HASH
+ProductSerializer.new(product).serializable # JSON
+
+# Index view
+ProductSerializer.new(product).serializable_hash(view: :index)
+ProductSerializer.new(product).serializable(view: :index)
+
+# Admin namespace with index view
+ProductSerializer.new(product).serializable_hash(namespace: :admin, view: :index)
+ProductSerializer.new(product).serializable(namespace: :admin, view: :index)
+```
+
+## Serializer Usage Examples
+
+### 1. All Attributes and Associations Serialization
+
+```ruby
+ProductSerializer.new(Product.objects(1)).serializable_hash
+```
+
+**Output:**
+```ruby
+{:id=>1,
+ :name=>"Name - 1",
+ :available_count=>499,
+ :price=>"$ 53.0",
+ :retail_price=>"$ 86.0",
+ :profit_margin=>"40%",
+ :specifications=>[{:id=>1, :name=>"SpecName - 1", :image=>"http://test.com/test.png"}, {:id=>2, :name=>"SpecName - 2", :image=>"http://test.com/test.png"}],
+ :offer=>
+  {:id=>1,
+   :name=>"Offer - 1",
+   :discount=>18,
+   :assets=>
+    [{:id=>1, :name=>"Offer - 1", :image=>"http://test.com/test.png", :type=>"image"},
+     {:id=>2, :name=>"Offer - 2", :image=>"http://test.com/test.png", :type=>"image"}]}}
+```
+
+### 2. View Attributes and Associations Serialization
+
+```ruby
+ProductSerializer.new(Product.objects).serializable_hash(view: :index)
+```
+
+**Output:**
+```ruby
+{:pagination=>{:count=>2, :page=>nil},
+ "products"=>
+  [{:id=>1,
+    :name=>"Name - 1",
+    :price=>"$ 87.0",
+    :offer=>
+     {:id=>1,
+      :name=>"Offer - 1",
+      :discount=>45,
+      :assets=>
+       [{:id=>1, :name=>"Offer - 1", :image=>"http://test.com/test.png", :type=>"image"},
+        {:id=>2, :name=>"Offer - 2", :image=>"http://test.com/test.png", :type=>"image"}]}},
+   {:id=>2,
+    :name=>"Name - 2",
+    :offer=>
+     {:id=>1,
+      :name=>"Offer - 1",
+      :discount=>25,
+      :assets=>
+       [{:id=>1, :name=>"Offer - 1", :image=>"http://test.com/test.png", :type=>"image"},
+        {:id=>2, :name=>"Offer - 2", :image=>"http://test.com/test.png", :type=>"image"}]}}]}
+```
+
+### 3. Namespace View Attributes and Associations Serialization
+
+```ruby
+ProductSerializer.new(Product.objects).serializable_hash(namespace: :admin, view: :index)
+```
+
+**Output:**
+```ruby
+[{:id=>1,
+  :name=>"Name - 1",
+  :price=>"$ 75.0",
+  :available_count=>680,
+  :profit_margin=>"1%",
+  :specifications=>[{:id=>1, :name=>"SpecName - 1"}, {:id=>2, :name=>"SpecName - 2"}],
+  :offer=>
+   {:id=>1,
+    :name=>"Offer - 1",
+    :assets=>[{:id=>1, :name=>"Offer - 1", :image=>"http://test.com/test.png"}, {:id=>2, :name=>"Offer - 2", :image=>"http://test.com/test.png"}]}},
+ {:id=>2,
+  :name=>"Name - 2",
+  :available_count=>274,
+  :profit_margin=>"45%",
+  :specifications=>[{:id=>1, :name=>"SpecName - 1"}, {:id=>2, :name=>"SpecName - 2"}],
+  :offer=>
+   {:id=>1,
+    :name=>"Offer - 1",
+    :assets=>[{:id=>1, :name=>"Offer - 1", :image=>"http://test.com/test.png"}, {:id=>2, :name=>"Offer - 2", :image=>"http://test.com/test.png"}]}}]
+```
+
+### Key Differences in Output:
+
+1. **Default Serialization**: Returns all defined attributes and associations for a single object
+2. **View Serialization**: Returns only the fields specified in the view definition, includes meta information with root key structure
+3. **Namespace View Serialization**: Returns fields specific to the namespace view, focuses on admin-specific data like `available_count` and `profit_margin`
+
+Notice how the view serialization includes pagination meta information at the root level with the actual data nested under the "products" key, while the namespace view returns a clean array structure focused on admin requirements.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` 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 the created tag, 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/jiren/flexi_view. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/jiren/flexi_view/blob/master/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the FlexiView project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/jiren/flexi_view/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/lib/flexi_view/association.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module FlexiView
+  class Association
+    attr_accessor :name, :serialized_name, :options, :data_block
+
+    def initialize(type, name, options, &data_block)
+      @type = type
+      @name = name
+      @options = options
+      @serialized_name = (@options[:as] || name).to_sym
+      @formatter = FlexiView.formatters[@options[:format]]
+      @data_block = data_block if block_given?
+    end
+
+    def serializer_class
+      @serializer_class ||= Object.const_get(options[:serializer_class].to_s)
+    end
+
+    def condition?(serializer)
+      return true if options[:if].nil?
+
+      if options[:if].is_a?(Proc)
+        serializer.instance_exec(&options[:if])
+      else
+        serializer.public_send(options[:if])
+      end
+    end
+
+    def to_data(parent_serializer, namespace, view)
+      parent_obj = parent_serializer.object
+
+      objects = if data_block
+                  parent_serializer.instance_exec(parent_obj, &data_block)
+                else
+                  parent_obj.public_send(name)
+                end
+
+      serializer = serializer_class.new(objects, options: parent_serializer.options)
+      serializer.serializable_hash(namespace: namespace, view: view)
+    end
+  end
+end

data/lib/flexi_view/attribute.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module FlexiView
+  class Attribute
+    attr_accessor :name, :serialized_name, :options, :formatter, :data_block
+
+    def initialize(name, options, &data_block)
+      @name = name
+      @options = options || {}
+      @serialized_name = (@options[:as] || name).to_sym
+      @formatter = FlexiView.formatters[@options[:format]]
+      @data_block = data_block if block_given?
+    end
+
+    def condition?(serializer)
+      return true if options[:if].nil?
+
+      if options[:if].is_a?(Proc)
+        serializer.instance_exec(&options[:if])
+      else
+        serializer.public_send(options[:if])
+      end
+    end
+
+    def to_data(serializer)
+      value = if data_block
+                serializer.instance_exec(serializer.object, &data_block)
+              else
+                serializer.object.public_send(name)
+              end
+
+      formatter ? formatter.format(value) : value
+    end
+  end
+end

data/lib/flexi_view/formatter.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module FlexiView
+  class Formatter
+    attr_accessor :name
+
+    def initialize(name, &block)
+      @name = name.to_sym
+      @formater_block = block
+    end
+
+    def format(value)
+      @formater_block.call(value)
+    end
+  end
+end

data/lib/flexi_view/meta.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module FlexiView
+  class Meta
+    attr_accessor :name, :root_key, :data_block
+
+    def initialize(name, root_key, &data_block)
+      @name = name
+      @root_key = root_key
+      @data_block = data_block if block_given?
+    end
+
+    def to_data(serializer)
+      serializer.instance_exec(serializer.objects, &data_block)
+    end
+  end
+end

data/lib/flexi_view/namespace.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module FlexiView
+  class Namespace
+    attr_accessor :name, :serializer, :views
+
+    def initialize(name, serializer)
+      @name = name
+      @serializer = serializer
+      @views = {}
+    end
+
+    def view(name)
+      @views[name.to_sym] = View.new(name.to_sym, serializer)
+    end
+  end
+end

data/lib/flexi_view/serializer.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require_relative "attribute"
+require_relative "association"
+require_relative "meta"
+require_relative "namespace"
+require_relative "view"
+
+module FlexiView
+  module Serializer
+    def self.included(klass)
+      klass.send :extend, Serializer::ClassMethods
+      klass.__init__
+    end
+
+    module ClassMethods
+      attr_reader :attribute_map, :association_map, :meta_map, :namespaces, :views
+
+      def __init__
+        @attribute_map = {}
+        @association_map = {}
+        @meta_map = {}
+        default_namespace = Namespace.new(:__default, self).tap { |ns| ns.view(:__default) }
+        @namespaces = { __default: default_namespace }
+      end
+
+      def __schema__
+        { attributes: @attribute_map.values }
+      end
+
+      def default_namespace
+        @namespaces[:__default]
+      end
+
+      def default_view
+        @namespaces[:__default].views[:__default]
+      end
+
+      def attribute(name, options = nil, &block)
+        if options && options[:format] && FlexiView.formatters[options[:format]].nil?
+          raise Error, "#{options[:format]} formatter not defined"
+        end
+
+        attr = Attribute.new(name.to_sym, options, &block)
+        attribute_map[attr.name] = attr
+        default_view.fields(attr.name)
+      end
+
+      # format and if params
+      def attributes(*names, **options)
+        names.each { |name| attribute(name, options) }
+      end
+
+      def many(name, serializer_class, options = nil, &block)
+        association(:many, name, serializer_class, options, &block)
+      end
+
+      def one(name, serializer_class, options = nil, &block)
+        association(:one, name, serializer_class, options, &block)
+      end
+
+      def meta(name, root_key:, &block)
+        raise Error, "code block required for meta #{name}" unless block_given?
+
+        m = Meta.new(name.to_sym, root_key.to_s, &block)
+        meta_map[m.name] = m
+      end
+
+      def view(name)
+        namespaces[:__default].view(name)
+      end
+
+      def namespace(name, &block)
+        raise Error, "'#{name}' namespace required code block" unless block_given?
+
+        name = name.to_sym
+
+        raise Error, "#{name} is already defined" if @namespaces[name]
+
+        @namespaces[name] = Namespace.new(name, self).tap do |ns|
+          ns.instance_exec(&block)
+        end
+      end
+
+      def find_view(namespace, view)
+        ns = namespace ? namespaces[namespace] : default_namespace
+
+        raise Error, "#{namespace} is not defined" unless ns
+
+        v = view ? ns.views[view] : ns.views[:__default]
+
+        raise Error, "#{view} is not defined for #{namespace || "default"} namespace" unless v
+
+        v
+      end
+
+      private
+
+      def association(type, name, serializer_class, options = nil, &block)
+        options ||= {}
+        options[:serializer_class] = serializer_class
+        assoc = Association.new(
+          type, name.to_sym, options, &block
+        )
+        association_map[assoc.name] = assoc
+        default_view.association(assoc.name)
+      end
+    end
+
+    attr_reader :options, :objects
+    attr_accessor :context, :object
+
+    def initialize(objects, options: nil)
+      @objects = objects
+      @options = options || {}
+    end
+
+    def serializable_hash(namespace: nil, view: nil)
+      v = self.class.find_view(namespace, view)
+      self.context = { namespace: namespace || :default, view: view || :default }
+      v.serializable_hash(self)
+    end
+
+    def serialize(namespace: nil, view: nil)
+      FlexiView.json_encoder.dump(
+        serializable_hash(namespace: namespace, view: view)
+      )
+    end
+  end
+end

data/lib/flexi_view/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module FlexiView
+  VERSION = "0.1.0"
+end

data/lib/flexi_view/view.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module FlexiView
+  class View
+    attr_accessor :name
+
+    def initialize(name, serializer_class)
+      @name = name
+      @serializer_class = serializer_class
+      @fields = {}
+      @associations = {}
+      @meta = nil
+    end
+
+    def fields(*names)
+      names.each do |n|
+        attr = @serializer_class.attribute_map[n.to_sym]
+
+        raise FlexiView::Error, "#{n} attribute not defined for #{@serializer_class}" unless attr
+
+        @fields[attr.name] = attr
+      end
+
+      self
+    end
+
+    def associations(*names, namespace: nil, view: nil)
+      names.each do |name|
+        association(name, namespace: namespace, view: view)
+      end
+
+      self
+    end
+
+    def association(name, namespace: nil, view: nil)
+      assoc = @serializer_class.association_map[name.to_sym]
+
+      raise FlexiView::Error, "#{name} association not defined for #{@serializer_class}" unless assoc
+
+      @associations[name.to_sym] = { association: assoc, namespace: namespace, view: view }
+
+      self
+    end
+
+    def meta(name)
+      @meta = @serializer_class.meta_map[name.to_sym]
+
+      raise FlexiView::Error, "#{name} meta defination found for #{@serializer_class}" unless @meta
+
+      self
+    end
+
+    def serializable_hash(serializer)
+      data = if serializer.objects.is_a?(Enumerable)
+               serializer.objects.map { |object| serialize_object(serializer, object) }
+             else
+               serialize_object(serializer, serializer.objects)
+             end
+
+      return data unless @meta
+
+      {
+        @meta.name => @meta.to_data(serializer),
+        @meta.root_key => data
+      }
+    end
+
+    def serialize_object(serializer, object)
+      serializer.object = object
+      result = {}
+
+      @fields.each_value do |attr|
+        result[attr.serialized_name] = attr.to_data(serializer) if attr.condition?(serializer)
+      end
+
+      @associations.each_value do |params|
+        assoc = params[:association]
+
+        next unless assoc.condition?(serializer)
+
+        result[assoc.serialized_name] = assoc.to_data(
+          serializer,
+          params[:namespace],
+          params[:view]
+        )
+      end
+
+      result
+    end
+  end
+end

data/lib/flexi_view.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "flexi_view/version"
+require_relative "flexi_view/formatter"
+require_relative "flexi_view/serializer"
+
+module FlexiView
+  class Error < StandardError; end
+
+  module ClassMethods
+    def json_encoder=(value)
+      @json_encoder = value
+    end
+
+    def json_encoder
+      @json_encoder
+    end
+
+    def formatter(name, &block)
+      raise Error, "required code block" unless block_given?
+
+      @formatters[name.to_sym] = Formatter.new(name, &block)
+    end
+
+    def formatters
+      @formatters
+    end
+
+    def __init__
+      self.json_encoder = JSON
+      @default_root_key = nil
+      @formatters = {}
+    end
+
+    def self.extended(base)
+      base.__init__
+    end
+  end
+
+  extend ClassMethods
+end

data/sig/flexi_serializer.rbs

@@ -0,0 +1,4 @@
+module FlexiView
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: flexi_view
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jiren Patel
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Flexible object serializer. Serialize object define using namespace and
+  view
+email:
+- jirenpatel@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/flexi_view.rb
+- lib/flexi_view/association.rb
+- lib/flexi_view/attribute.rb
+- lib/flexi_view/formatter.rb
+- lib/flexi_view/meta.rb
+- lib/flexi_view/namespace.rb
+- lib/flexi_view/serializer.rb
+- lib/flexi_view/version.rb
+- lib/flexi_view/view.rb
+- sig/flexi_serializer.rbs
+homepage: https://github.com/jiren/flexi_view
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/jiren/flexi_view
+  source_code_uri: https://github.com/jiren/flexi_view
+  changelog_uri: https://github.com/jiren/flexi_view
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.15
+specification_version: 4
+summary: Flexible object serializer. Serialize object define using namespace and view
+test_files: []