rails-formation 0.0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ad157ec88ba25d8f9197ed69ad68c6a83ea79a92a38ca158c74582988b4af285
+  data.tar.gz: dcf51b0e646da2778ca9e813b8a550881af5a08e81cdb8de3e376a1655f68bed
+SHA512:
+  metadata.gz: b3ffc89976c3718500ffaa12e5d96238af9dc090037fc80d648992d4705e55b058212caf86fce0afedb09fce4e70bf6ec7beb5770b1b7492ef971b046195a506
+  data.tar.gz: 14701d72714814a0041443f315ee8c06d857a8cbd3175bddc47b18f187d71c5d8daa4a305b2aebe10c55ecd842f8b291a1ff3bb1c0797300278d9f6e688aabc3

data/README.md

@@ -0,0 +1,19 @@
+# Rails formation
+
+Plan and bootstrap Ruby on Rails application at the same time. Skip the boring part of the development. Visit https://railsformation.com and create your first formation.
+
+## 🚀 Installation
+
+Install gem globally not per project:
+
+```shell
+gem install rails-formation
+```
+
+## 📚 Usage
+
+After you download formation from the project:
+
+```shell
+formation apply template.json
+```

data/bin/formation

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'rails-formation'
+
+command_line_arguments = ARGV.dup
+
+RailsFormation::Cli::Processor.new(command_line_arguments).call

data/lib/rails-formation/cli/api_adapter.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RailsFormation
+  module Cli
+    class ApiAdapter
+      def initialize(uid)
+        @uid = uid
+      end
+
+      def template
+        # pull from railsformation.com API
+      end
+    end
+  end
+end

data/lib/rails-formation/cli/file_adapter.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module RailsFormation
+  module Cli
+    class FileAdapter
+      def initialize(file_path)
+        @file_path = file_path
+      end
+
+      def template
+        raw_json = File.read(@file_path)
+        JSON.parse(raw_json)
+      end
+    end
+  end
+end

data/lib/rails-formation/cli/processor.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RailsFormation
+  module Cli
+    class Processor
+      COMMANDS = %w[apply].freeze
+
+      InvalidCommand = Class.new(StandardError)
+      InvalidUid = Class.new(StandardError)
+
+      def initialize(args)
+        @command = args[0]
+        @uid = args[1]
+      end
+
+      def call
+        validate_command
+
+        ::RailsFormation.apply(adapter.template)
+      end
+
+      private
+
+      def validate_command
+        raise InvalidCommand, "command #{@command} is not supported!" unless COMMANDS.include?(@command.to_s.downcase)
+      end
+
+      def adapter
+        case @uid
+        when /.*.json$/
+          ::RailsFormation::Cli::FileAdapter.new(@uid)
+        when /^rft-.*/
+          ::RailsFormation::Cli::ApiAdapter.new(@uid)
+        else
+          raise InvalidUid, "#{@uid} is not valid template file or UID"
+        end
+      end
+    end
+  end
+end

data/lib/rails-formation/formatters/factories/column.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative 'default_value'
+require_relative 'value'
+
+module RailsFormation
+  module Formatters
+    module Factories
+      class Column
+        def initialize(config)
+          @config = config
+        end
+
+        def to_s
+          if @config.key?('has_confirmation')
+            base_part = "#{name} { #{value} }"
+            "#{base_part}\n  #{name}_confirmation { #{name} }"
+          else
+            "#{name} { #{value} }"
+          end
+        end
+
+        private
+
+        def name
+          @config.fetch('name')
+        end
+
+        def sql_type
+          @config.fetch('sql_type')
+        end
+
+        def specialized
+          @config.fetch('specialized')
+        end
+
+        def use_sql_type?
+          specialized == 'default'
+        end
+
+        def default_value
+          ::RailsFormation::Formatters::Factories::DefaultValue
+        end
+
+        def value
+          if @config.key?('in')
+            "#{@config.fetch('in')}.sample"
+          else
+            raw_value
+          end
+        end
+
+        def raw_value
+          if use_sql_type?
+            ::RailsFormation::Formatters::Factories::DefaultValue.detect(sql_type)
+          else
+            ::RailsFormation::Formatters::Factories::Value.detect(specialized)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails-formation/formatters/factories/default_value.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RailsFormation
+  module Formatters
+    module Factories
+      class DefaultValue
+        MAPPINGS = {
+          'string' => 'FFaker::Lorem.sentence',
+          'text' => 'FFaker::Lorem.sentence(50)',
+          'boolean' => 'FFaker::Boolean.maybe',
+          'time' => 'Time.zone.now',
+          'date' => 'FFaker::Time.date',
+          'float' => 'FFaker::Number.decimal',
+          'decimal' => 'FFaker::Number.decimal',
+          'integer' => 'FFaker::Number.number',
+          'binary' => '',
+          'timestamp' => 'Time.now.getutc',
+          'datetime' => 'DateTime.now'
+        }.freeze
+
+        def self.detect(sql_type)
+          MAPPINGS[sql_type]
+        end
+      end
+    end
+  end
+end

data/lib/rails-formation/formatters/factories/value.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RailsFormation
+  module Formatters
+    module Factories
+      class Value
+        MAPPINGS = {
+          'first_name' => 'FFaker::Name.first_name',
+          'last_name' => 'FFaker::Name.last_name',
+          'zip_code' => 'FFaker::AddressUS.zip_code',
+          'state' => 'FFaker::AddressUS.state',
+          'city' => 'FFaker::Address.city',
+          'street_name' => 'FFaker::Address.street_name',
+          'building_number' => 'FFaker::Address.building_number',
+          'country_code' => 'FFaker::Address.country_code',
+          'country' => 'FFaker::Address.country',
+          'time_zone' => 'FFaker::Address.time_zone',
+          'plane_name' => 'FFaker::Airline.name',
+          'flight_number' => 'FFaker::Airline.flight_number',
+          'animal' => 'FFaker::AnimalUS.common_name',
+          'iban' => 'FFaker::Bank.iban',
+          'card_number' => 'FFaker::Bank.card_number',
+          'card_type' => 'FFaker::Bank.card_number',
+          'card_expiry_date' => 'FFaker::Bank.card_expiry_date',
+          'book_title' => 'FFaker::Book.title',
+          'book_genre' => 'FFaker::Book.genre',
+          'book_author' => 'FFaker::Book.author',
+          'book_isbn' => 'FFaker::Book.isbn',
+          'boolean' => 'FFaker::Boolean.maybe',
+          'color' => 'FFaker::Color.name',
+          'color_hex_code' => 'FFaker::Color.hex_code',
+          'company_name' => 'FFaker::Company.name',
+          'position' => 'FFaker::Company.position',
+          'currency_code' => 'FFaker::Currency.code',
+          'currency_name' => 'FFaker::Currency.name',
+          'currency_symbol' => 'FFaker::Currency.symbol',
+          'education_degree' => 'FFaker::Education.degree',
+          'school_name' => 'FFaker::Education.school_name',
+          'ingredient' => 'FFaker::Food.ingredient',
+          'vegetable' => 'FFaker::Food.vegetable',
+          'fruit' => 'FFaker::Food.fruit',
+          'meat' => 'FFaker::Food.meat',
+          'game_title' => 'FFaker::Game.title',
+          'game_category' => 'FFaker::Game.category',
+          'gender_binary' => 'FFaker::Gender.binary',
+          'gender_random' => 'FFaker::Gender.random',
+          'latitude' => 'FFaker::Geolocation.lat',
+          'longitude' => 'FFaker::Geolocation.lng',
+          'email' => 'FFaker::Internet.email',
+          'username' => 'FFaker::Internet.user_name',
+          'domain' => 'FFaker::Internet.domain_name',
+          'slug' => "Faker::Internet.slug(nil, '-')",
+          'job_title' => 'FFaker::Job.title',
+          'locale' => 'FFaker::Locale.code',
+          'language' => 'FFaker::Locale.language',
+          'movie' => 'FFaker::Movie.title',
+          'name' => 'FFaker::Name.name',
+          'number' => 'FFaker::Number.number',
+          'decimal' => 'FFaker::Number.decimal',
+          'phone_number' => 'FFaker::PhoneNumber.phone_number',
+          'brand_name' => 'FFaker::Product.brand',
+          'product_name' => 'FFaker::Product.product_name',
+          'tech_skill' => 'FFaker::Skill.tech_skill',
+          'specialty' => 'FFaker::Skill.specialty',
+          'sport_name' => 'FFaker::SportUS.name',
+          'ssn' => 'FFaker::SSN.ssn',
+          'month' => 'FFaker::Time.month',
+          'datetime' => 'FFaker::Time.datetime',
+          'date' => 'FFaker::Time.date'
+        }.freeze
+
+        def self.detect(specialized)
+          MAPPINGS[specialized]
+        end
+      end
+    end
+  end
+end

data/lib/rails-formation/formatters/factory.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative 'factories/column'
+
+module RailsFormation
+  module Formatters
+    class Factory < Thor::Group
+      include Thor::Actions
+
+      argument :factory_configuration
+      argument :factory_path
+
+      def create_factory
+        template('../templates/factory.rb.tt', factory_path)
+      end
+
+      def self.source_root
+        __dir__
+      end
+
+      private
+
+      def factory_name
+        factory_configuration.fetch('name')
+      end
+
+      def associations
+        []
+      end
+
+      def columns
+        factory_configuration.fetch('fields', []).map do |config|
+          RailsFormation::Formatters::Factories::Column.new(config).to_s
+        end
+      end
+    end
+  end
+end

data/lib/rails-formation/formatters/migration.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative 'migrations/column'
+require_relative 'migrations/index'
+
+module RailsFormation
+  module Formatters
+    class Migration < Thor::Group
+      include Thor::Actions
+
+      argument :migration_configuration
+      argument :migration_path
+
+      def create_migration
+        template('../templates/migration.rb.tt', migration_path)
+      end
+
+      def self.source_root
+        __dir__
+      end
+
+      private
+
+      def table_name
+        migration_configuration.fetch('table')
+      end
+
+      def timestamps?
+        migration_configuration.fetch('timestamps', false)
+      end
+
+      def columns
+        migration_configuration.fetch('columns', []).map do |config|
+          RailsFormation::Formatters::Migrations::Column.new(config).to_s
+        end
+      end
+
+      def indices
+        migration_configuration.fetch('indices', []).map do |config|
+          RailsFormation::Formatters::Migrations::Index.new(table_name, config).to_s
+        end
+      end
+    end
+  end
+end

data/lib/rails-formation/formatters/migrations/column.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RailsFormation
+  module Formatters
+    module Migrations
+      class Column
+        def initialize(config)
+          @config = config
+        end
+
+        def to_s
+          base_definition = [
+            't.',
+            @config.fetch('type'),
+            ' :',
+            @config.fetch('name')
+          ].join
+
+          return base_definition if @config['options'].nil? || @config['options'].size.zero?
+
+          options = @config['options'].map do |option|
+            value = option['value']
+            parsed_value = value.is_a?(String) ? "'#{value}'" : value
+
+            "#{option['name']}: #{parsed_value}"
+          end.join(', ')
+
+          [base_definition, ', ', options].join
+        end
+      end
+    end
+  end
+end

data/lib/rails-formation/formatters/migrations/index.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RailsFormation
+  module Formatters
+    module Migrations
+      class Index
+        def initialize(table_name, config)
+          @table_name = table_name
+          @config = config
+        end
+
+        def to_s
+          column_slug = if @config.fetch('column_names').size == 1
+                          ":#{@config.fetch('column_names').first}"
+                        else
+                          "[#{@config.fetch('column_names').map { |col| ":#{col}" }.join(', ')}]"
+                        end
+
+          base_definition = "add_index :#{@table_name}, #{column_slug}"
+
+          return base_definition if @config.fetch('options', []).size.zero?
+
+          options = @config['options'].map { |option| option.values.join(': ') }.join(', ')
+
+          "#{base_definition}, #{options}"
+        end
+      end
+    end
+  end
+end

data/lib/rails-formation/formatters/model.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'models/validation'
+
+module RailsFormation
+  module Formatters
+    class Model < Thor::Group
+      include Thor::Actions
+
+      argument :model_configuration
+      argument :model_path
+
+      def create_model
+        template('../templates/model.rb.tt', model_path)
+      end
+
+      def self.source_root
+        __dir__
+      end
+
+      private
+
+      def class_name
+        model_configuration.fetch('name')
+      end
+
+      def validations
+        models_with_validations = model_configuration.fetch('columns', []).select do |config|
+          config.fetch('validations', []).size.positive?
+        end
+
+        models_with_validations.map do |config|
+          config.fetch('validations', []).map do |val_config|
+            ::RailsFormation::Formatters::Models::Validation.new(
+              val_config.merge('column' => config.fetch('name'))
+            ).to_s
+          end
+        end.flatten
+      end
+    end
+  end
+end

data/lib/rails-formation/formatters/models/validation.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative 'validations/base'
+require_relative 'validations/presence'
+require_relative 'validations/uniqueness'
+require_relative 'validations/length'
+require_relative 'validations/inclusion'
+require_relative 'validations/exclusion'
+require_relative 'validations/confirmation'
+require_relative 'validations/format'
+require_relative 'validations/numericality'
+require_relative 'validations/comparsion'
+
+module RailsFormation
+  module Formatters
+    module Models
+      class Validation
+        MAPPINGS = {
+          'presence' => ::RailsFormation::Formatters::Models::Validations::Presence,
+          'uniqueness' => ::RailsFormation::Formatters::Models::Validations::Uniqueness,
+          'length' => ::RailsFormation::Formatters::Models::Validations::Length,
+          'inclusion' => ::RailsFormation::Formatters::Models::Validations::Inclusion,
+          'exclusion' => ::RailsFormation::Formatters::Models::Validations::Exclusion,
+          'confirmation' => ::RailsFormation::Formatters::Models::Validations::Confirmation,
+          'format' => ::RailsFormation::Formatters::Models::Validations::Format,
+          'numericality' => ::RailsFormation::Formatters::Models::Validations::Numericality,
+          'comparsion' => ::RailsFormation::Formatters::Models::Validations::Comparsion
+        }.freeze
+
+        def initialize(config)
+          @config = config
+        end
+
+        def to_s
+          klass = MAPPINGS[@config.fetch('name')]
+          klass.new(@config).to_s
+        end
+      end
+    end
+  end
+end

data/lib/rails-formation/formatters/models/validations/base.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RailsFormation
+  module Formatters
+    module Models
+      module Validations
+        class Base
+          def initialize(config)
+            @config = config
+          end
+
+          private
+
+          def allow_blank_option
+            return unless @config.fetch('allow_blank')
+
+            'allow_blank: true'
+          end
+
+          def allow_nil_option
+            return unless @config.fetch('allow_nil')
+
+            'allow_nil: true'
+          end
+
+          def message_option
+            return if @config.fetch('message').nil? || @config.fetch('message').empty?
+
+            "message: '#{@config.fetch('message')}'"
+          end
+
+          def on_option
+            return if @config.fetch('on_create') && @config.fetch('on_update')
+
+            if @config.fetch('on_create')
+              'on: :create'
+            elsif @config.fetch('on_update')
+              'on: :update'
+            end
+          end
+
+          def column_name
+            @config.fetch('column')
+          end
+
+          def base_options
+            [
+              allow_blank_option,
+              allow_nil_option,
+              message_option,
+              on_option
+            ].compact
+          end
+
+          def validation_options
+            @config.fetch('options', {})
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails-formation/formatters/models/validations/comparsion.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RailsFormation
+  module Formatters
+    module Models
+      module Validations
+        class Comparsion < RailsFormation::Formatters::Models::Validations::Base
+          def to_s
+            "validates :#{column_name}, comparsion: { #{extra_options.join(', ')} }"
+          end
+
+          private
+
+          def extra_options
+            base_options | extra_validation_options
+          end
+
+          def extra_validation_options
+            value = if validation_options['comparsion_value_type'] == 'column_value'
+                      ":#{validation_options['comparsion_value']}"
+                    else
+                      validation_options['comparsion_value']
+                    end
+
+            ["#{validation_options['comparsion_operator']}: #{value}"]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails-formation/formatters/models/validations/confirmation.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RailsFormation
+  module Formatters
+    module Models
+      module Validations
+        class Confirmation < RailsFormation::Formatters::Models::Validations::Base
+          def to_s
+            if base_options.any?
+              "validates :#{column_name}, confirmation: { #{base_options.join(', ')} }"
+            else
+              "validates :#{column_name}, confirmation: true"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails-formation/formatters/models/validations/exclusion.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RailsFormation
+  module Formatters
+    module Models
+      module Validations
+        class Exclusion < RailsFormation::Formatters::Models::Validations::Base
+          def to_s
+            "validates :#{column_name}, exclusion: { #{extra_options.join(', ')} }"
+          end
+
+          private
+
+          def extra_options
+            base_options | extra_validation_options
+          end
+
+          def extra_validation_options
+            ["in: #{validation_options['in']}"]
+          end
+        end
+      end
+    end
+  end
+end