choron_support 0.1.9 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 650ed706fe5c243363f5a83fc8029023897c19a2cfc6b8973abcd85a8ba8b28e
-  data.tar.gz: 96ee27b7f7ac4de9f717ad2ea8ec5076f2d08462f440bc6107175fc6fe1dd9fe
+  metadata.gz: 5f5e95a92c449d959b9e9522a05e244461e98fb078b5405c93ceb873fdc5c49b
+  data.tar.gz: cec6ee644f7813d21e24039aadd30a6047e3a708a48cced1412f593c68be626a
 SHA512:
-  metadata.gz: 5ae8dba1af0adfa9dac9adc55056dedcb7c9fc191ed2cbc3d2650eb6d992f1b3974f1d6138f76fea7a5fc616c51220782451abaa85aa12d01f8f7828b1ea0831
-  data.tar.gz: eb17113982a53b1ae1b888ad798ab22433bfb8b4e603cf0aaee767f51fe4e3bdc872cad18f178350bb5b8aa7f370fed6e5a13bec83c344802b09980b518f0113
+  metadata.gz: a77b9097a63624fc09fdea17886eb85861c37272058938739692b812fd728d658602020c1b56f0ac3d2ed7f08e51f3b9b234dac28d23e9590620b81ac6794e08
+  data.tar.gz: 5ceff8def9787ebf4bdadf656173669f5ef1271cf27e08b41ec22b122b134f1f3e19ef70f59674a3a714eb4061e617fd381ea0a84a8c542b2bb6f9803fc02cba

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    choron_support (0.1.9)
+    choron_support (0.1.10)
       activesupport
 
 GEM

data/README.md

@@ -25,13 +25,9 @@ ChoronSupport.using :all
 
 * 必要に応じて各種モジュールをincludeすることで利用できます
 
-### AsProps
-
-モデルをJSON(キーがローキャメルケース)に変換するための仕組みです。
-
-* 詳細な使い方は [テストファイル](./spec/choron_support/as_props_spec.rb) を参照ください。
-* 詳細な実装は [こちら](./lib/choron_support/as_props.rb) です。
+### Props
 
+* [Props ドキュメント](./docs/props.md)を参照ください
 
 ### Mask
 

data/docs/props.md

@@ -11,225 +11,25 @@ Choronでは画面側の処理をReact + Typescrip の組み合わせで実現
 一般的なJSON化ツールの違いとしては、Javascript側の記法・慣習を優先するため、
 JSONのキーをローキャメルケース(fullName, isAdult,など)に自動変換します
 
-## Choronでの使い方
+## 使い方
 
-### 基本的な使い方
-
-ChoronにはChoronSupportにある
-* ChoronSupport::Props::Base
-* ChoronSupport::Props::Attributes
-の2つのクラス・モジュールを継承&includedしたProps用の基底クラスを用意しています。
-
-```app/models/props/base.rb
-class Props::Base < ChoronSupport::Props::Base
-  include ChoronSupport::Props::Attributes
-end
-```
-
-そして以下の命名ルールにより、モデルごとのPropsクラスを作成しています
-* app/models/props/${モデル名}.rb
-  * 例: app/models/props/user.rb
-これは ChoronSupport::AsProps モジュールがモデル名から自動で props/**/*.rb を探し出してインスタンスを生成してくれる処理に由来します。
-
-```app/models/props/user.rb
-class Props::Foo < Props::Base
-  attributes :id, :name, :full_name
-  attributes :full_name, to: :self
-  def full_name
-    "#{model.first_name} #{model.last_name}"
-  end
-end
-```
-
-これで準備は完了です。
-以下のようにController等で利用ができます
-
-```app/controllers/users_controller.rb
-class UsersController < ApplicationController
-  def index
-    users = User.all
-    props = {
-      users: users.as_props
-    }
-
-    render react_file(props: props)
-  end
-
-  def show
-    user = User.find(params[:id])
-    props = {
-      user: user.as_props
-    }
-
-    render react_file(props: props)
-  end
-end
-```
-
-サンプルコードからわかるように `#as_props` というメソッドはモデルおよびRelationの両方で利用が可能なように拡張をしています。
-
-この拡張を使うためには ChoronSupport::AsProps モジュールを ApplicationRecord にinclude する必要があります。
-
-Choronではすでに実施済です。
-
-```app/models/application_record.rb
-class ApplicationRecord < ActiveRecord::Base
-  include ChoronSupport::AsProps
-end
-```
-
-もしPropsクラスをわざわざ作らず、モデルのカラムをそのまま全てローキャメルケースで出したい時もあると思います。そのときは
-
-```
-user.as_props(:model)
-```
-
-と第一引数で `:model` を渡すことで、カラム全てをprops化します。
-※これは個人情報など思わぬ値も出力してしまう可能性もあるため、安全な処理にだけ使うことを推奨します
-
-また、キーワード引数を使うことでパラメーターを渡すことも可能です。
-これを利用すれば、Props側を利用する側から細かいPropsの出力調整ができます。
-
-```app/models/props/foo.rb
-class Props::Foo < Props::Base
-  attributes :id, :name
-  attributes :full_name, if: :show_name?
-  def show_name?
-    # #params で as_props 実行時のキーワード引数にアクセスができる
-    params[:show_name].present?
-  end
-end
-```
-
-これは以下のように利用できます
-
-```
-foo = Foo.find(1)
-foo.as_props(show_name: true)
-```
-
-また、この `DSL` を使うことで以下の情報がメタ情報として自動的に出力されます。
-* type: Props化を行なったクラスの名前(名前空間あり)
-* modelName: Props化を行なったモデルの名前(名前空間なし)
-
-```app/models/props/foos/bar.rb
-class Props::Foos::Bar < Props::Base
-  attributes :id, :name
+```ruby
+class Props::Samples::Foo < Props::Base
+  attribute :id
+  attribute :full_name
 end
-```
-
-Foos::Bar.new.as_props
-#=> { id: x, name: "xxx", type: "Foos::Bar", modelName: "Bar" }
-
-もし `RAILS_ENV=test` のときはさらに Props化を行なったクラスもメタ情報として付与されます。
-
-Foos::Bar.new.as_props
-#=> { id: x, name: "xxx", type: "Foos::Bar", modelName: "Bar", propsClassName: "Props::Foos::Bar" }
-
-このメタ情報を使うことでテストの簡略化も可能となります。
-
-例えば Controller のテストを以下のように書くことができます。
-
-```spec/requests/foos_controller_spec.rb
-describe FoosController, type: :request do
-  describe "GET /foos/:id" do
-    let!(:id) { foo.id }
-    let!(:foo) { create(:foo) }
-    it "詳細画面が表示されること" do
-      is_expected.to eq 200
-
-      react = rendered_react("foo/show")
-      props = react.props
-      # 細かい値の設定はProps側の単体テストで担保しているため、ここでは使われているPropsのみ検証する
-      expect(props[:foo][:propsClassName]).to eq "Props::Foos::Bar"
-      # Choron では専用のマッチャーがあるため以下のように記載も可能
-      expect(props[:foo]).to be_use_props(Props::Foos::Bar)
-    end
-  end
-end
-```
-
-### DSLの細かい使い方
-* ChoronSupport::Props::Attributesのソースコードを参照ください
-  * https://github.com/mksava/choron_support/blob/main/lib/choron_support/props/attributes.rb
-
-### Propsの設計思想
-ChoronでのPropsはattributesのDSLでif文の指定が可能です。
-そうでなくてもpropsメソッドをオーバーライドすることでさらに細かい調整が可能です。
-
-しかしPropsの設計思想は「1つのPropsで複数のパターンのJSONを作成する」よりも「複数のパターンがある分、Propsクラスを作成する」にあります。
-
-たとえば「User」には個人情報が含まれいるため、Propsの出力を制御したいときは
-
-* 一般的な利用
-  * `app/models/props/user.rb`
-* スタッフなど個人情報にアクセス可能なユーザからの利用
-  * `app/models/props/users/staff.rb`
-* ログインしているユーザ自身が自分自身の情報を見たいときに利用
-  * `app/models/props/users/current.rb`
-
-というようにPropsクラスを複数作成することを検討してください。
-このとき、各Propsクラスは以下のように `#as_props` の第一引数を指定することで利用できます
-
-```
-# app/models/props/users/general.rb
-users = Users.all.as_props(:general)
-# app/models/props/users/staff.rb
-users = Users.all.as_props(:staff)
-# app/models/props/users/current.rb
-users = Users.all.as_props(:current)
-```
-
-## サンプルコード
-
-* Props を作成するときはこのサンプルコードを優先的に参考にしてください
-* Sample の部分は適宜作成したいモデル名に変更してください
-
-### ActiveRecord
-
-```app/models/sample.rb
-class Sample < ApplicationRecord
-end
-```
-
-```app/controllers/samples_controller.rb
-class SamplesController < ApplicationController
-  def index
-    samples = Sample.all
-    props = {
-      samples: samples.as_props(:general)
-    }
-
-    render react_file(props: props)
-  end
-end
-```
-
-```app/models/props/sample.rb
-class Props::Sample < Props::Base
-  attributes :id, :name, :created_at, :updated_at
-  attributes :is_sample?, to: :self
 
-  def is_sample?
-    true
-  end
-end
+sample = Sample.new(id: 100, full_name: "mksava")
+sample.as_props(:foo)
+#=> { id: 100, fullName: "mksava", type: "Foo", modelName: "Foo" }
 ```
 
-```app/models/props/samples/general.rb
-class Props::Samples::Genral < Props::Base
-  attributes :id, :created_at, :updated_at
-  attributes :is_sample?, to: :self
-
-  def is_sample?
-    false
-  end
-end
-```
-
-```app/models/props/samples/staff.rb
-class Props::Samples::Staff < Props::Base
-  self.union = :default
-  attributes :salary
-end
-```
+* 詳細な使い方はテストファイルを参照ください。
+  * [一般的な使い方](../spec/choron_support/as_props/general_spec.rb)
+  * [エッジケース](../spec/choron_support/as_props/edge_spec.rb)
+  * [attribute DSLの使い方](../spec/choron_support/as_props/attribute_spec.rb)
+  * [inherit DSL の使い方](../spec/choron_support/as_props/inherit_spec.rb)
+  * [relation DSLの使い方](../spec/choron_support/as_props/relation_spec.rb)
+* 実装は以下を参照ください
+  * [as_props.rb](../lib/choron_support/as_props.rb)
+  * [props/](../lib/choron_support/props/)

data/lib/choron_support/as_props.rb

@@ -9,14 +9,14 @@ module ChoronSupport
     # @param [Hash] params その他のパラメータ。camel: false を指定すると自動でキャメライズしない。
     # @return [Hash]
     def as_props(type_symbol = nil, **params)
-      serializer = self.__get_props_class(type_symbol, params)
+      pass_params = params.except(:camel)
 
+      serializer = self.__get_props_class(type_symbol, pass_params)
       skip_camel = (params[:camel] == false)
-      pass_params = params.except(:camel)
       if serializer.nil?
         skip_camel ? self.as_json : self.as_json.as_camel
       else
-        skip_camel ? serializer.as_props(**pass_params) : serializer.as_props(**pass_params).as_camel
+        skip_camel ? serializer.as_props : serializer.as_props.as_camel
       end
     end
 
@@ -31,14 +31,15 @@ module ChoronSupport
         class_name = type_symbol.to_s.classify
         # 例: Serialize::Users::FooBar
         props_class_name = "#{namespace}::#{class_name}"
-      when nil
-        namespace = "Props"
-        # 例: User / Master::Plan
-        class_name = self.class.to_s
-        # 例: Props::User
-        props_class_name = "#{namespace}::#{class_name}"
+      when Class
+        given_class = type_symbol
+        if given_class.ancestors.include?(ChoronSupport::Props::Base)
+          props_class_name = given_class.to_s
+        else
+          raise ArgumentError, "invalid class: #{given_class}"
+        end
       else
-        raise ArgumentError
+        raise ArgumentError, "invalid type_symbol: #{type_symbol}"
       end
 
       begin
@@ -46,11 +47,6 @@ module ChoronSupport
 
         props_class.new(self, params)
       rescue *rescue_errors
-        # もしmodelを指定しているときはnilを返し、as_jsonを利用させる
-        if type_symbol == :model
-          return nil
-        end
-
         if type_symbol.blank?
           raise ChoronSupport::AsProps::NameError, "Props class not found: #{props_class_name}. Please create props class."
         else

data/lib/choron_support/props/attributes.rb

@@ -1,381 +1,215 @@
-# 本クラス は include 先のクラスに対してキャメルケースのJSONを設定するためのDSLやメソッドを提供するモジュールです
-# このモジュールをincludeしたクラスは以下のような形で使うことを想定しています
-# @examle
-#   [app/models/values/money.rb]
-#   class Values::Money
-#     include ChoronSupport::Props::Attributes
-#     attributes :amount, :amount_with_unit, to: :self
-#     def initialize(amount)
-#       @amount = amount.to_i
-#     end
-#     def amount
-#       @amount
-#     end
-#     def amount_with_unit
-#       "#{amount}円"
-#     end
-#   end
-# Choronではデフォルトで以下のようなBaseクラスが作成されて、読み込みがされています
-# @example
-#   class Props::Base < ChoronSupport::Props::Base
-#     include ChoronSupport::Props::Attributes
-#   end
-# [使い方]
-# @example 最も簡単な例
-#   [app/models/props/user.rb]
-#   class Props::User < Props::Base
-#     # id, full_name, ageを出力させる
-#     # retult: { id: 1, fullName: "John Smith", age: 20 }
-#     attributes :id, :full_name, :age
-#   end
-# @example メソッドのデリゲート先を指定する
-#   [app/models/props/user.rb]
-#   class Props::User < Props::Base
-#     # result: { fullName: "John Smith" }
-#     attributes :full_name, to: :self
-#     def full_name
-#       "#{model.first_name} #{model.last_name}"
-#     end
-#   end
-# @example 関連先のModelのPropsを結合する
-#   class Props::User < Props::Base
-#     # result: { posts: posts.as_props } => { posts: [{ id: 1, title: "foo" }, { id: 2, title: "bar" }] }
-#     relation :posts
-#   end
-#
-# これらの各種DSLは複数同時に設定することもできます
-# @example 複数設定
-#   [app/models/props/user.rb]
-#   class Props::User < Props::Base
-#     # id, full_name, ageを出力させる
-#     attributes :id, :age
-#     attributes :full_name, to: :self
-#     relation :posts
-#     def full_name
-#       "#{model.first_name} #{model.last_name}"
-#     end
-#   end
-#
-# default値の設定やifオプションを渡して出力有無を動的に変更もできます
-# @example default, ifの設定
-#   [app/models/props/user.rb]
-#   class Props::User < Props::Base
-#     # age が nil のときは 0 を出力する
-#     # age が 20 以上のときのみ出力する
-#     attributes :age, default: 0, if: :show_age?
-#     def show_age?
-#       model.age >= 20
-#     end
-#   end
-#
-#
-# 本DSLを利用するときは基本的には attributes を使って設定するのが良いと思います
-# 細かな使い方モジュールの該当DSL(self.xxxx)の説明を参照してください
-module ChoronSupport
-  module Props
-    module Attributes
-      FORMATS = {
-        # HTMLのinput type="date"で使える形式
-        date: "%Y-%m-%d",
-        datetime: "%Y-%m-%dT%H:%M",
-      }.freeze
-      # 型のキャスト指定があってもキャストはしないメソッド
-      CAST_IGNORE_METHODS = [
-        # id は数値のほうが良いため
-        :id,
-      ].freeze
-      # デフォルト値を設定しない場合に使う値
-      NO_DEFAULT = Object.new.freeze
-
-      extend ActiveSupport::Concern
-
-      included do
-        # 本moduleはActiveSupportが使える環境でのみ動作します
-        unless defined?(ActiveSupport)
-          raise "ActiveSupport is not defined. Please require 'active_support/all' in your Gemfile"
-        end
-
-        # DSLで設定できる設定値たち ==========================
-        #  Props作成時に設定されるキーと値を設定します。
-        #  この値はDSLを経由して内部的に設定されていきます
-        class_attribute :settings_attributes
-        #  Props作成時に自動で付与される元のクラスの文字列を設定しないときはtrueを設定してください
-        #  @example
-        #    class Props::Foo < Props::Base
-        #      self.skip_meta_mark = true
-        #    end
-        class_attribute :skip_meta_mark, default: false
-        #  他のPropsクラスの結果を結合するときに結合先のProps識別子を設定してください
-        # @example
-        #   class Props::Foos::General < Props::Base
-        #     # すべてのカラムを出す
-        #     self.union = :model
-        #     # as_props の結果を結合する
-        #     self.union = :default
-        #     # as_props(:secure) の結果を結合する
-        #     self.union = :secure
-        #   end
-        class_attribute :union, default: nil
-        # ====================================================
-
-        # Props作成時に設定されるキーと値を設定します。
-        # @param [Symbol] key Propsのキーを指定してください
-        # @param [Symbol] method 値を代入するためのメソッドを指定してください。指定がないときはkeyをメソッドとして扱います
-        # @param [Symbol] to メソッドのデリゲート先を指定してください。指定がないときはmodelをデリゲート先として扱います。:selfを指定すると自身をデリゲート先として扱います
-        # @param [Symbol] cast デリゲート先のメソッドの戻り値に対して、さらにメソッドを実行するときは指定してください。
-        # @param [Object] default 値がnilのときに設定されるデフォルト値を指定してください。指定がないときはnilになります。
-        # @param [Proc | Symbol] if その値を出すときの条件。Symbolだとselfに対してsendを実行します
-        def self.attribute(key, method: nil, to: :model, cast: nil, default: NO_DEFAULT, if: nil)
-          self.settings_attributes ||= []
-          self.settings_attributes << { key:, to:, method: (method || key), cast:, default:, if: }
-        end
-
-        # 一度にまとめて複数のattributeを設定します
-        # 基本的なパラメータの説明はattributeを参照してください
-        # @param [Array<Symbol>] methods 設定するキーと値のペアを指定してください
-        # @example
-        #   model = User.new(id: 1, name: "John", email: "JOHN@EXAMPLE", age: nil)
-        #   class Props::User::Foo < ChoronSupport::Props::Base
-        #     attributes :id, :name, :email, :age
-        #       #=> { id: 1, name: "John", email: "JOHN@EXAMPLE", age: nil }
-        #   end
-        # @note to, cast, defaultなどのパラメータについて
-        #   これらの値は全てのメソッド・キーに対して同じ値が設定されます
-        def self.attributes(*methods, to: :model, cast: nil, default: NO_DEFAULT, if: nil)
-          methods.each do |method|
-            attribute(method, method:, to:, cast:, default:, if:)
-          end
-        end
-
-        # Modelに対して関連付けされた別ModelのPropsを結合するためのDSLです
-        # to, cast, default, if については attribute と同じです
-        # @param [Symbol] key Propsのキーを指定してください
-        # @param [Symbol] relation 結合するModelのメソッドを指定してください。指定がないときはkeyをメソッドとして扱います
-        # @example
-        #   class Props::User < ChoronSupport::Props::Base
-        #     relation :posts
-        #     #=> { posts: user.posts.as_props } と同じ結果になる
-        #     relation :posts, props: :foo_bar
-        #     #=> { posts: user.posts.as_props(:foo_bar) } と同じ結果になる
-        #     relation :user_posts, relation: :posts
-        #     #=> { user_posts: user.posts.as_props } と同じ結果になる
-        #   end
-        def self.relation(key, relation: nil, to: :model, cast: nil, default: NO_DEFAULT, props: nil, if: nil)
-          relation ||= key
-          method = lambda { |model|
-            records = model.send(relation)
-            if props
-              records&.as_props(props) || {}
-            else
-              records&.as_props || {}
-            end
-          }
-          self.attribute(
-            key,
-            method:,
-            to:,
-            cast:,
-            default:,
-            if:,
-          )
-        end
-
-        # self.relation の複数同時に設定ができるversionです
-        # 基本は上記と一緒ですが、relationとkeyは同じである必要があります
-        # @example
-        #   class Props::User < ChoronSupport::Props::Base
-        #     relations :posts, :comments
-        #     #=> { posts: user.posts.as_props, comments: user.comments.as_props } と同じ結果になる
-        #   end
-        def self.relations(*keys, to: :model, cast: nil, default: NO_DEFAULT, props: nil, if: nil)
-          keys.each do |key|
-            method = lambda { |model|
-              records = model.send(key)
-              if props
-                records&.as_props(props) || {}
-              else
-                records&.as_props || {}
-              end
-            }
-            self.attribute(
-              key,
-              method:,
-              to:,
-              cast:,
-              default:,
-              if:,
-            )
-          end
-        end
-
-        # Propsに設定されるキーと値のペアを返します
-        # @param 各種パラメータは self.attribute に合わせているためそちらを参照してください
-        # @return [Hash] 設定されるPropsのキーと値のペア
-        # @note memo
-        #   if が予約語のため options として受け取っています。_ifも検討しましたが全体でキーワードの形を合わせたかったためoptionsの形にしています
-        def attribute(key, method: nil, to: :model, cast: nil, default: NO_DEFAULT, **options)
-          __build_props_attribute__(key, (method || key), to, cast, default, **options)
-        end
-
-        # 一度にまとめて複数のattributeを設定します
-        # パラメータは self.attributes に合わせているためそちらを参照してください
-        def attributes(*methods, to: :model, cast: nil, default: nil, **options)
-          _props = {}
-          methods.each do |method|
-            key = method.to_sym
-            unit_props = __build_props_attribute__(key, method, to, cast, default, **options)
+require_relative "./private/type_builder"
+require_relative "./private/setting"
+module ChoronSupport::Props::Attributes
+  unless defined?(ActiveSupport)
+    raise "ActiveSupport is not defined. Please require 'active_support/all' in your Gemfile"
+  end
 
-            _props.merge!(unit_props)
-          end
+  extend ActiveSupport::Concern
+
+  included do
+    # DSLで設定できる設定値たち ==========================
+    #  Props作成時に設定されるキーと値を設定します。
+    #  この値はDSLを経由して内部的に設定されていきます
+    class_attribute :settings, instance_writer: false, default: nil
+    #  Props作成時に自動で付与される元のクラスの文字列を設定しないときはtrueを設定してください
+    #  @example
+    #    class Props::Foos::Bar
+    #      self.skip_meta_mark = true
+    #    end
+    class_attribute :skip_meta_mark, default: false
+    # Propsから自動でtypescriptの型を生成しないときはfalseを設定してください
+    # @example
+    #   class Props::Foos::Bar
+    #     self.skip_typescript = true
+    #   end
+    class_attribute :skip_typescript, default: false
+    #  他のPropsクラスの設定を継承するときに設定されます
+    class_attribute :inherit_props_class, default: nil
+    # ====================================================
+
+    # Propsとして出力する属性を設定するためのDSLです
+    # @param [Symbol] method モデル, もしくは to オプションで設定したオブジェクトに対して実行するメソッドを指定してください
+    # @param [Keyword] options その他のオプションを指定してください
+    #   @option [Symbol] :to 指定したメソッドを実行するオブジェクトを指定できます
+    #   @option [Symbol | lambda] :if 属性を出力するための条件を指定できます
+    #   @option [Symbol] :cast 属性を出力する前に指定したメソッドを実行できます。
+    #   @option [Boolean] :default 属性値がnilのときに代わりに出力する値を指定できます
+    #   @option [Proc] &block ブロックを渡すとそのブロックの戻り値を属性値として出力します
+    def self.attribute(method, **options, &block)
+      setting_params = options.merge(method: method, block: block)
+      setting = ChoronSupport::Props::Private::Setting.new(setting_params)
+
+      self.settings ||= []
+      self.settings << setting
+    end
 
-          # ブロックが渡されていれば実行する
-          if block_given?
-            _props = yield(_props)
-          end
+    # 他のPropsクラスの設定を継承するためのDSLです
+    # @param [ChoronSupport::Props::Base] inherit_props_class 継承するPropsクラスを指定してください
+    # @example
+    #   class Props::Users::General < ChoronSupport::Props::Base
+    #     inherit Props::Users::Base
+    #   end
+    def self.inherit(props_class)
+      # 継承するクラスはProps::Baseを継承している必要があります
+      unless props_class.ancestors.include?(ChoronSupport::Props::Base)
+        raise "inherit class must be ChoronSupport::Props::Base. got: #{props_class}"
+      end
 
-          # Classのマークをつける(テスト用)
-          _props.merge!(__build_props_class_mark__)
-          # Modelのマークをつける
-          _props.merge!(__build_props_meta_mark__)
+      # 既に継承先が設定されている場合はエラーにします
+      if self.inherit_props_class.present?
+        raise "inherit props inherit class already set: #{self.inherit_props_class}.(Only one class can be inherited)"
+      end
 
-          _props
-        end
+      self.inherit_props_class = props_class
+      self.settings ||= []
+      self.inherit_props_class.settings.to_a.each do |setting|
+        self.settings << setting
+      end
+    end
 
-        # @override
-        #   Props::Base#as_props をオーバーライドしています
-        #   本モジュールを読み込んだクラスではas_propsはオーバーライドせず、DSLとpropsメソッドを上書きしてください
-        # @note 仕様
-        #   クラス側で設定されたattribute, attributesを元にPropsを作成します
-        #   もしくはオーバーライドされているであろう props の結果を設定します
-        #   もし両方を設定しているときはどちらの値も設定されます
-        #     キーがかぶっているときはprops側が優先されます
-        # @return [Hash] props
-        def as_props
-          _props = {}
+    # Modelに対して関連付けされた別ModelのPropsを結合するためのDSLです
+    # @param [Symbol] method to オプションで指定されたオブジェクトに実行されるメソッドを指定してください
+    # @param [ChoronSupport::Props::Base] props モデルをProps化するためのクラスを指定してください
+    # @param [Keyword] options その他のオプションを指定してください。詳細は attribute と同じです
+    # @example
+    #   class Props::Users::General < ChoronSupport::Props::Base
+    #     relation :posts, props: Props::Posts::General
+    #     #=> { posts: user.posts.as_props(:general) } と同じ結果になる
+    #   end
+    def self.relation(method, props_class, **options)
+      self.attribute(method, **options) do |model, params|
+        records = model.send(method)
+        records&.as_props(props_class, **params)
+      end
+    end
+  end
 
-          # 結合先が指定されていればその結合先のpropsを取得する
-          if self.class.union.present?
-            if self.class.union == :default
-              _props.merge!(model.as_props)
-            else
-              _props.merge!(model.as_props(self.class.union))
-            end
-          end
+  # @return [Hash] props
+  def as_props
+    _props = {}
 
-          # DSLの設定があればそれを設定する
-          self.class.settings_attributes.to_a.each do |settings|
-            _props.merge!(
-              attribute(settings[:key], method: settings[:method], to: settings[:to], cast: settings[:cast], default: settings[:default], if: settings[:if])
-            )
-          end
+    # DSLの設定を設定する
+    self.class.settings.to_a.each do |setting|
+      _props.merge!(__build_props_attribute__(setting))
+    end
 
-          # Classのマークをつける(テスト用)
-          _props.merge!(__build_props_class_mark__)
-          # Modelのマークをつける
-          _props.merge!(__build_props_meta_mark__)
-          # Propsがオーバーライドされていればその値で上書きする
-          _props.merge!(self.props)
+    # Classのマークをつける(テスト用)
+    _props.merge!(__build_props_class_mark__)
+    # Modelのマークをつける
+    _props.merge!(__build_props_meta_mark__)
 
-          _props
-        end
+    _props
+  end
 
-        # @return [Hash] props
-        # @note
-        # 　オーバーライドして使うことを想定しています
-        def props
-          {}
-        end
-      end
+  private
 
-      private
+  def model
+    raise NotImplementedError, "model method is not implemented"
+  end
 
-      # @param [Array<Symbol>] methods
-      # @param [Symbol] key
-      # @param [Symbol] to メソッドのデリゲート先
-      # @param [Block] blockを渡すと実行結果をブロック引数でわたし、その中の戻り値を結果として返します
-      # @param [Symbol] cast デリゲート先のメソッドの戻り値に対して、さらにメソッドを実行する
-      # 複雑性を増す代わりに集約をさせています
-      def __build_props_attribute__(key, method, to, cast, default, **options)
-        props = {}
+  def params
+    raise NotImplementedError, "params method is not implemented"
+  end
 
-        _if = options[:if]
-        if _if.present?
-          result = _if.is_a?(Proc) ? _if.call(model) : send(_if)
-          return {} unless result
-        end
+  FORMATS = {
+    # HTMLのinput type="date"で使える形式
+    date: "%Y-%m-%d",
+    datetime: "%Y-%m-%dT%H:%M",
+  }.freeze
+  # 型のキャスト指定があってもキャストはしないメソッド
+  CAST_IGNORE_METHODS = [
+    # id は数値のほうが良いため
+    :id,
+  ].freeze
+  # @param [Array<Symbol>] Setting
+  def __build_props_attribute__(setting)
+    attribute = {}
+
+    _if = setting.if
+    if _if.present?
+      result = send(_if)
+      return {} unless result
+    end
 
-        # javascriptは?をキーとして使えないので削除しつつ、isXxx形式に変換する
-        if key.to_s.end_with?("?")
-          key = key.to_s.gsub("?", "").to_sym
-          key = "is_#{key}".to_sym unless key.start_with?("is_")
-        end
+    # javascriptは?をキーとして使えないので削除しつつ、isXxx形式に変換する
+    key = setting.name
+    if key.to_s.end_with?("?")
+      key = key.to_s.gsub("?", "").to_sym
+      key = "is_#{key}".to_sym unless key.start_with?("is_")
+    end
 
-        # valはこの後の工程で書き換えの可能性があるため注意
-        if to == :self
-          if method.is_a?(Proc)
-            val = method.call(self)
-          else
-            val = send(method)
-          end
+    # valはこの後の工程で書き換えの可能性があるため注意
+    val = nil
+    method = setting.method
+    to = setting.to
+    if setting.block.present?
+      val = setting.block.call(model, params)
+    else
+      if to == :self
+        if method.is_a?(Proc)
+          val = method.call(self)
         else
-          if method.is_a?(Proc)
-            val = method.call(send(to))
-          else
-            val = send(to)&.send(method)
-          end
+          val = send(method)
         end
-
-        case val
-        when Date
-          val = val.strftime(FORMATS[:date])
-        when ActiveSupport::TimeWithZone, Time
-          # 日付系であればjsで使えるようにhtmlに変換する
-          val = val.strftime(FORMATS[:datetime])
+      else
+        if method.is_a?(Proc)
+          val = method.call(send(to))
         else
-          if cast.present? && CAST_IGNORE_METHODS.exclude?(key)
-            val = cast.to_s.split(".").inject(val) do |lval, cast_method|
-              lval.send(cast_method)
-            end
-          end
+          val = send(to)&.send(method)
         end
+      end
+    end
 
-        if val.nil? && default != NO_DEFAULT
-          val = default
+    case val
+    when Date
+      val = val.strftime(FORMATS[:date])
+    when ActiveSupport::TimeWithZone, Time
+      # 日付系であればjsで使えるようにhtmlに変換する
+      val = val.strftime(FORMATS[:datetime])
+    else
+      if setting.cast.present? && CAST_IGNORE_METHODS.exclude?(key)
+        val = setting.cast.to_s.split(".").inject(val) do |lval, cast_method|
+          lval.send(cast_method)
         end
+      end
+    end
 
-        props[key] = val
+    if val.nil? && setting.set_default?
+      val = setting.default
+    end
 
-        props
-      end
+    attribute[key] = val
 
-      # テストモードのときはどのPropsを実行したかを判定できるように属性をつけたします
-      def __build_props_class_mark__
-        mark = {}
-        if ENV["RAILS_ENV"] == "test"
-          mark[:props_class_name] = self.class.name
-          if self.class.union.present?
-            mark[:union_type_name] = self.class.union
-          end
-        end
+    attribute
+  end
 
-        mark
+  # テストモードのときはどのPropsを実行したかを判定できるように属性をつけたします
+  def __build_props_class_mark__
+    mark = {}
+    if ENV["RAILS_ENV"] == "test"
+      mark[:props_class_name] = self.class.name
+      if self.class.inherit_props_class.present?
+        mark[:inherit_props_class_name] = self.class.inherit_props_class.try(:name) || self.class.inherit_props_class.to_s
       end
+    end
 
-      # どのモデルのPropsかを判定できるように属性をつけたします
-      def __build_props_meta_mark__
-        return {} if self.class.skip_meta_mark
+    mark
+  end
 
-        type_target = begin
-          model
-        rescue StandardError
-          self
-        end
+  # どのモデルのPropsかを判定できるように属性をつけたします
+  def __build_props_meta_mark__
+    return {} if self.class.skip_meta_mark
 
-        {
-          type: type_target.class.try(:name).to_s,
-          model_name: type_target.class.try(:name).try(:demodulize).to_s,
-        }
-      end
+    type_target = begin
+      model
+    rescue StandardError
+      self
     end
+
+    {
+      type: type_target.class.try(:name).to_s,
+      model_name: type_target.class.try(:name).try(:demodulize).to_s,
+    }
   end
 end

data/lib/choron_support/props/base.rb

@@ -1,24 +1,10 @@
-# 本クラスはChoronSupportを利用しているRailsで継承されることを想定して作成されてます
-# Choronでは以下のようにBaseクラスがデフォルトで作成されています
-# @example
-#   [app/models/props/base.rb]
-#   class Props::Base < ChoronSupport::Props::Base
-#     include ChoronSupport::Props::Attributes
-#   end
-# そして各種モデルのPropsは上記のBaseクラスを継承して作成されています
-# @example
-#   [app/models/props/user.rb]
-#   class Props::User < Props::Base
-#     attributes :id, :name, :age
-#   end
-#   [app/models/props/users/secure.rb]
-#   class Props::Users::Secure < Props::Base
-#     # secure側はageは非表示
-#     attributes :id, :name
-#   end
+require_relative "./attributes"
+
 module ChoronSupport
   module Props
     class Base
+      include ChoronSupport::Props::Attributes
+
       # @param [ActiveRecord::Base] model Props対象のモデルのインスタンス
       # @param [Hash] params その他のパラメータ
       def initialize(model, params = {})
@@ -26,15 +12,20 @@ module ChoronSupport
         @params = params
       end
 
-      # 継承先で実装されることを想定しています
-      # ChoronSupport::Props::Attributes を読み込んでいるときは、そちらでオーバーライドされています
-      def as_props
-        raise NotImplementedError
-      end
-
       private
 
-      attr_reader :model, :params
+      # @override
+      def model
+        @model
+      end
+
+      # @override
+      def params
+        @params
+      end
     end
   end
 end
+
+__END__
+abcd

data/lib/choron_support/props/private/setting.rb

@@ -0,0 +1,42 @@
+class ChoronSupport::Props::Private::Setting
+  class Error < StandardError; end
+  # デフォルト値を設定しない場合に使う値
+  NO_DEFAULT = Object.new.freeze
+  private_constant :NO_DEFAULT
+  SETTING_ATTRIBUTES = %i[method name to cast default if block].freeze
+  private_constant :SETTING_ATTRIBUTES
+
+  SETTING_ATTRIBUTES.each {|atr_name| attr_reader atr_name }
+
+  def initialize(params)
+    # 不正なオプションがあれば例外を発生させる
+    if (params.keys - SETTING_ATTRIBUTES).present?
+      raise Error, "invalid params: #{(params.keys - SETTING_ATTRIBUTES).join(", ")}, valid params are #{SETTING_ATTRIBUTES.join(", ")}"
+    end
+
+    @method = params[:method]
+    @name = params[:name] || @method
+    @to = params[:to] || :model
+    @cast = params[:cast]
+    @default = params[:default] || NO_DEFAULT
+    @if = params[:if] || nil
+    @block = params[:block] || nil
+
+    check_params!
+  end
+
+  def set_default?
+    self.default != NO_DEFAULT
+  end
+
+  private
+
+  def check_params!
+    if name.blank?
+      raise Error, "name is required"
+    end
+    if method.blank?
+      raise Error, "method is required"
+    end
+  end
+end

data/lib/choron_support/props/private/type_builder.rb

@@ -0,0 +1,129 @@
+# @deprecated
+class ChoronSupport::Props::Private::TypeBuilder
+  RESULT =  Struct.new(:file_path, :body, :type_name, :attributes)
+
+  # @return [String]
+  # @memo
+  #   必要に応じてoverrideしてください
+  def self.output_dir
+    "app/javascript/types/props"
+  end
+
+  # @return [String]
+  # @memo
+  #   必要に応じてoverrideしてください
+  def self.file_path(props_class)
+    self.default_build_file_path(props_class)
+  end
+
+  def initialize(props_class)
+    @body_buffer = []
+    @attributes_buffer = []
+    @props_class = props_class
+  end
+
+  # 設定値やクラス名からTypeScriptの型を生成する
+  # @return [RESULT]
+  # @example
+  #   class Foo::Bars::Staff < Props::Base
+  #     attribute :id, type: "number | null"
+  #     attribute :name, type: "string"
+  #     attribute :is_super, type: "boolean",
+  #     attribute :license_names, type: "Array<string>"
+  #   end
+  #   builder = ChoronSupport::Props::Private::TypeBuilder.new(Foo::Bars::Staff)
+  #   builder.build
+  #   ####====#####
+  #   type Foo_Bars_StaffProps = {
+  #     id: number | null,
+  #     name: string,
+  #     is_super: boolean,
+  #     license_names: Array<string>,
+  #     type: "Foo::Bars::Staff"
+  #     modelName: "Foo::Bar"
+  #   }
+  #   ####====#####
+  def build
+    set_type_buffer
+
+    file_path = self.class.file_path(props_class)
+    body = body_buffer.join("\n")
+    type_name = build_type_name(props_class)
+    attributes = attributes_buffer.join("\n")
+
+    RESULT.new(file_path, body, type_name, attributes)
+  end
+
+  # buildされたTypeScriptの型をファイルに出力する
+  # @return [RESULT]
+  def generate
+    result = self.build
+
+    # 出力用のディレクトリがなければ作成する
+    if !Dir.exist?(self.class.output_dir)
+      FileUtils.mkdir_p(self.class.output_dir)
+    end
+
+    # ファイルを作成する
+    File.open(result.file_path, "w") do |f|
+      f.puts(result.body)
+    end
+
+    result
+  end
+
+  def __body_buffer__
+    body_buffer
+  end
+
+  private
+
+  attr_reader :props_class, :body_buffer, :attributes_buffer
+
+  def self.default_build_file_path(props_class)
+    # 分かりやすいようにそのままtypenameをファイル名にする
+    file_name = props_class.name.gsub("::", "_") + ".d.ts"
+
+    if defined?(Rails) && Rails.root.present?
+      Rails.root.join(self.output_dir, file_name).to_s
+    else
+      File.join(self.output_dir, file_name)
+    end
+  end
+
+  def set_type_buffer
+    body_buffer << "type #{build_type_name(props_class)} = {"
+    attributes_buffer = "{"
+
+    build_attributes(props_class).each do |attr_val|
+      body_buffer << "  #{attr_val}"
+      attributes_buffer << "  #{attr_val}"
+    end
+
+    body_buffer << "}"
+    attributes_buffer << "}"
+  end
+
+  def build_attributes(props_class)
+    attributes = []
+    props_class.settings.each do |setting|
+      attributes << build_attribute(setting)
+    end
+
+    attributes
+  end
+
+  def build_attribute(setting)
+    name = setting.name
+    _if  = setting.if
+    name_val = "#{name}#{_if ? "?" : ""}"
+
+    type = setting.type
+
+    "#{name_val}: #{type}"
+  end
+
+  def build_type_name(props_class)
+    props_class.name.gsub("::", "_")
+  end
+end

data/lib/choron_support/props/private/type_generator.rb

@@ -0,0 +1,62 @@
+# @deprecated
+class ChoronSupport::Props::Private::TypeGenerator
+  def run
+    start_output
+
+    results = []
+    targer_props.each do |props_class|
+      result = builder_class.new(props_class).generate
+      results << result
+    end
+
+    output_results(results)
+
+    results
+  end
+
+  private
+
+  def target_props_class?(props_class)
+    props_class.respond_to?(:skip_typescript) && props_class.respond_to?(:settings)
+  end
+
+  def self.props_base
+    Props::Base
+  end
+
+  def targer_props
+    props_list = []
+    self.class.props_base.descendants.each do |props_class|
+      next unless target_props_class?(props_class)
+      next if props_class.skip_typescript
+
+      props_list << props_class
+    end
+
+    props_list
+  end
+
+  def builder_class
+    ChoronSupport::Props::Private::TypeBuilder
+  end
+
+  def start_output
+    log("Start generating TypeScript Props...: #{targer_props.size}")
+  end
+
+  def output_results(results)
+    log("Generated TypeScript Props: #{results.size}")
+    log("for...")
+    results.each do |result|
+      log("  #{result.file_path}")
+    end
+
+    log("Done.")
+  end
+
+  def log(str)
+    @logger_method ||= defined?(Rails) ? Rails.logger.method(:info) : method(:puts)
+
+    @logger_method.call(str)
+  end
+end

data/lib/choron_support/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ChoronSupport
-  VERSION = "0.1.9"
+  VERSION = "0.1.10"
 end

data/lib/choron_support.rb

@@ -1,6 +1,12 @@
 # frozen_string_literal: true
 
 module ChoronSupport
+  module Domains; end
+  module Forms; end
+  module Props; end
+  module Props::Private; end
+  module Queries; end
+
   SUPPORT_FILES = {
     domains: "choron_support/domain_delegate",
     queries: "choron_support/scope_query",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: choron_support
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.10
 platform: ruby
 authors:
 - mksava
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-12-05 00:00:00.000000000 Z
+date: 2024-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -212,6 +212,9 @@ files:
 - lib/choron_support/props/base.rb
 - lib/choron_support/props/ext/hash.rb
 - lib/choron_support/props/ext/relation.rb
+- lib/choron_support/props/private/setting.rb
+- lib/choron_support/props/private/type_builder.rb
+- lib/choron_support/props/private/type_generator.rb
 - lib/choron_support/queries/base.rb
 - lib/choron_support/scope_query.rb
 - lib/choron_support/set_mask_for.rb