sutty-cli 0.1.1 → 0.3.0rc2

data/lib/sutty/cli/commands/post.rb

@@ -6,6 +6,7 @@ require 'tty-file'
 require 'yaml'
 require 'securerandom'
 require 'jekyll/utils'
+require 'faker'
 
 module Sutty
   module Cli
@@ -16,7 +17,8 @@ module Sutty
         CONTENT_FIELDS = %w[content markdown_content].freeze
 
         def initialize(options)
-          @options = options
+          @options = options.to_h
+          @options['title'] ||= random_string(10)
         end
 
         def execute(input: $stdin, output: $stdout)
@@ -25,7 +27,10 @@ module Sutty
             return true
           end
 
-          TTY::File.create_file path, YAML.dump(data) + "---\n\n"
+          TTY::File.create_file path,
+                                YAML.dump(data) +
+                                "---\n\n" +
+                                (content? ? random_markdown : '')
         end
 
         private
@@ -33,11 +38,13 @@ module Sutty
         def data
           return @data if @data
 
-          @data = Hash[(data_layout.keys - CONTENT_FIELDS).map { |k| [k, nil] }]
+          @data = (data_layout.keys - CONTENT_FIELDS).map do |k|
+            [k, generate_data(k)]
+          end.to_h
 
           # Required fields
-          @data['title']  = options[:title]
-          @data['layout'] = options[:layout]
+          @data['title']  = options['title']
+          @data['layout'] = options['layout']
           @data['uuid']   = SecureRandom.uuid
           @data['liquid'] = false
 
@@ -45,24 +52,118 @@ module Sutty
         end
 
         def data_layout
-          @data_layout ||= YAML.safe_load(File.read(File.join('_data', 'layouts', options[:layout] + '.yml')))
+          @data_layout ||= YAML.safe_load(File.read(File.join('_data', 'layouts', options['layout'] + '.yml')))
         end
 
         def slug
-          @slug ||= Jekyll::Utils.slugify(options[:title])
+          @slug ||= Jekyll::Utils.slugify(options['title'])
         end
 
         def dir
-          @dir ||= '_' + options[:locale]
+          @dir ||= '_' + options['locale']
         end
 
         def path
-          @path ||= File.join(dir, options[:date] + '-' + slug + '.markdown')
+          @path ||= File.join(dir, options['date'] + '-' + slug + '.markdown')
         end
 
         def logger
           @logger ||= TTY::Logger.new
         end
+
+        def generate_data(key)
+          # TODO: Generate private data
+          return if data_layout[key]['private']
+          # Sometimes data is optional
+          return unless data_layout[key]['required'] || random_boolean
+
+          case data_layout[key]['type']
+          when 'string' then random_text(1)
+          when 'text' then random_text(3)
+          when 'markdown' then random_markdown(3)
+          when 'number' then random_number(255)
+          when 'order' then random_number(255)
+          when 'tel' then Faker::PhoneNumber.phone_number
+          when 'date' then Faker::Date.in_date_period
+          when 'array' then Array.new(random_number(10)) { random_string(random_number(3)) }
+          when 'predefined_array' then data_layout[key]['values'].keys.sample
+          when 'boolean' then random_boolean
+          when 'color' then random_color
+          when 'email' then Faker::Internet.email
+          when 'url' then Faker::Internet.url
+          when 'file' then random_file
+          when 'image' then random_file
+          when 'belongs_to' then random_post(key)
+          when 'has_many' then random_posts(key)
+          when 'has_and_belongs_to_many' then random_posts(key)
+          when 'locales' then random_posts(key)
+          when 'related_posts' then random_posts
+          when 'geo'
+            {
+              'lat' => Faker::Address.latitude,
+              'lng' => Faker::Address.longitude
+            }
+          end
+        end
+
+        def random_number(digits)
+          rand(1..digits)
+        end
+
+        def random_text(longitude = nil)
+          longitude ||= long? ? random_number(20) : random_number(5)
+
+          Faker::Lorem.paragraphs(number: longitude).join("\n\n")
+        end
+
+        def random_string(longitude = random_number(10))
+          Faker::Lorem.sentence(word_count: longitude)
+        end
+
+        def random_markdown(longitude = nil)
+          longitude ||= long? ? random_number(20) : random_number(5)
+
+          Faker::Markdown.sandwich(sentences: longitude,
+                                   repeat: long? ? random_number(5) : 1)
+        end
+
+        def long?
+          options['content'] == 'long'
+        end
+
+        def random_color
+          Random.bytes(3).unpack1('H*')
+        end
+
+        def random_boolean
+          @random_boolean ||= [true,false]
+
+          @random_boolean.sample
+        end
+
+        def random_file
+          {
+            'path' => 'public/placeholder.png',
+            'description' => random_string(1)
+          }
+        end
+
+        # TODO: Implement relationships between posts
+        def random_post(key = nil)
+          SecureRandom.uuid
+        end
+
+        def random_posts(key = nil)
+          Array.new(random_number(10)) { random_post(key) }
+        end
+
+        def types
+          @types ||= data_layout.values.map { |v| v['type'] }.uniq
+        end
+
+        def content?
+          @content ||= CONTENT_FIELDS.map { |f| types.include? f }.any?
+        end
       end
     end
   end

data/lib/sutty/cli/commands/theme.rb

@@ -6,6 +6,8 @@ require 'tty-command'
 module Sutty
   module Cli
     module Commands
+      # Genera una plantilla nueva, a partir de sutty-base-jekyll-theme
+      # y realiza la configuración inicial del repositorio.
       class Theme < Sutty::Cli::Command
         attr_reader :name
 
@@ -20,27 +22,30 @@ module Sutty
           Dir.chdir theme_name do
             cmd.run('git remote rename origin upstream')
             cmd.run('git remote add origin', origin)
+            cmd.run('git lfs fetch --all upstream')
             cmd.run('git push -u origin master')
-            cmd.run('bundle install')
-            cmd.run('yarn install')
             cmd.run('git mv sutty-base-jekyll-theme.gemspec', gemspec)
           end
         end
 
         private
 
+        # @return [String]
         def theme_name
-          @theme_name ||= name + '-jekyll-theme'
+          @theme_name ||= "#{name}-jekyll-theme"
         end
 
+        # @return [String]
         def origin
-          @origin ||= 'git@0xacab.org:sutty/jekyll/' + theme_name + '.git'
+          @origin ||= "git@0xacab.org:sutty/jekyll/#{theme_name}.git"
         end
 
+        # @return [String]
         def gemspec
-          @gemspec ||= theme_name + '.gemspec'
+          @gemspec ||= "#{theme_name}.gemspec"
         end
 
+        # @return [TTY::Command]
         def cmd
           @cmd ||= TTY::Command.new
         end

data/lib/sutty/cli/i18n.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'i18n'
+
+locale  = ENV['LANG'].split('_', 2).first.to_sym
+locales = Dir["#{File.expand_path(File.join(__dir__, '..', '..', '..', 'config', 'locales'))}/*.yml"]
+
+I18n::Backend::Simple.include(I18n::Backend::Memoize)
+I18n.load_path = locales
+I18n.available_locales = locales.map { |l| File.basename(l, '.yml') }.map(&:to_sym)
+I18n.default_locale = :es
+I18n.locale = I18n.available_locales.include?(locale) ? locale : :es

data/lib/sutty/cli/version.rb

@@ -2,6 +2,6 @@
 
 module Sutty
   module Cli
-    VERSION = "0.1.1"
+    VERSION = "0.3.0rc2"
   end
 end

data/lib/sutty/drop_stub.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# A veces necesitamos una versión falsa de esto para Jekyll::Utils
+unless Object.const_defined? 'Jekyll::Drops::Drop'
+  module Jekyll
+    module Drops
+      class Drop ; end
+    end
+  end
+end

data/lib/sutty/schema.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+require 'jekyll/utils'
+
+module Sutty
+  # Genera definiciones de campos para Sutty
+  class Schema
+    class << self
+      ATTRIBUTES = %i[type required private writable inverse filter]
+
+      # Definición base.
+      #
+      # Se eliminan los valores que son falsos o están vacíos.
+      #
+      # @return [Hash]
+      def base(**args)
+        validate_field_type(args[:type])
+
+        args.slice(*ATTRIBUTES).transform_keys(&:to_s).reject do |_, v|
+          v == false || v.nil?
+        end.merge(t(**args))
+      end
+
+      def create(type:, **args)
+        validate_field_type(type)
+
+        public_send :"#{type}_field", **args
+      end
+
+      # Aplica traducciones
+      #
+      # @param :type [String]
+      # @param :name [String]
+      # @return [Hash] traducciones
+      def t(**args)
+        require_relative 'drop_stub'
+
+        I18n.available_locales.map do |locale|
+          I18n.with_locale(locale) do
+            %i[name type].map do |translation|
+              translation = I18n.t("fields.common_by_#{translation}.#{args[translation]}")
+
+              next if translation.is_a? String
+
+              translation
+            end.compact.first
+          end
+        end.compact.reduce({}) do |t, l|
+          Jekyll::Utils.deep_merge_hashes(t, l)
+        end
+      end
+
+      # Texto de una sola línea
+      #
+      # @return [Hash]
+      def string_field(name:, **args)
+        { name => base(type: 'string', name: name, **args) }
+      end
+
+      # Texto de varias líneas
+      #
+      # @return [Hash]
+      def text_field(name:, **args)
+        { name => base(type: 'text', name: name, **args) }
+      end
+
+      # Números
+      #
+      # @return [Hash]
+      def number_field(name:, **args)
+        { name => base(type: 'number', name: name, **args) }
+      end
+
+      # URL
+      #
+      # @return [Hash]
+      def url_field(name:, **args)
+        { name => base(type: 'url', name: name, **args) }
+      end
+
+      # E-mail
+      #
+      # @return [Hash]
+      def email_field(name:, **args)
+        { name => base(type: 'email', name: name, **args) }
+      end
+
+      # Teléfono
+      #
+      # @return [Hash]
+      def tel_field(name:, **args)
+        { name => base(type: 'tel', name: name, **args) }
+      end
+
+      # Color
+      #
+      # @return [Hash]
+      def color_field(name:, **args)
+        { name => base(type: 'color', name: name, **args) }
+      end
+
+      # SKU
+      #
+      # @return [Hash]
+      def sku_field(name:, **args)
+        { name => base(type: 'sku', name: name, **args) }
+      end
+
+      # Precio.  Los precios se escriben una sola vez.
+      #
+      # @return [Hash]
+      def price_field(name:, **args)
+        { name => base(type: 'price', name: name, writable: 'once', **args) }
+      end
+
+      # Permalinks
+      #
+      # @return [Hash]
+      def permalink_field(name:, **args)
+        { name => base(type: 'permalink', name: name, **args) }
+      end
+
+      # Orden
+      #
+      # @return [Hash]
+      def order_field(name:, **args)
+        { name => base(type: 'order', name: name, **args) }
+      end
+
+      # Verdadero/falso
+      #
+      # @return [Hash]
+      def boolean_field(name:, **args)
+        { name => base(type: 'boolean', name: name, **args) }
+      end
+
+      # Contenido
+      #
+      # @return [Hash]
+      def content_field(name:, **args)
+        { name => base(type: 'content', name: name, **args) }
+      end
+
+      # HTML
+      #
+      # @return [Hash]
+      def html_field(name:, **args)
+        { name => base(type: 'html', name: name, **args) }
+      end
+
+      # Oculto
+      #
+      # @return [Hash]
+      def hidden_field(name:, **args)
+        { name => base(type: 'hidden', name: name, **args) }
+      end
+
+      # Fecha
+      #
+      # @return [Hash]
+      def date_field(name:, **args)
+        { name => base(type: 'date', name: name, **args) }
+      end
+
+      # Coordenadas geográficas
+      #
+      # @return [Hash]
+      def geo_field(name:, **args)
+        { name => base(type: 'geo', name: name, **args) }
+      end
+
+      # Archivo
+      #
+      # @return [Hash]
+      def file_field(name:, **args)
+        { name => base(type: 'file', name: name, **args) }
+      end
+
+      # Imagen
+      #
+      # @return [Hash]
+      def image_field(name:, **args)
+        { name => base(type: 'image', name: name, **args) }
+      end
+
+      # Array
+      #
+      # @return [Hash]
+      def array_field(name:, **args)
+        { name => base(type: 'array', name: name, **args) }
+      end
+
+      # Relacionados sin relación recíproca
+      #
+      # @return [Hash]
+      def related_posts_field(name:, **args)
+        { name => base(type: 'related_posts', name: name, **args) }
+      end
+
+      # Relación de muchos a uno, la relación recíproca es has_many
+      #
+      # @return [Hash]
+      def belongs_to_field(name:, filter:, value:, **args)
+        { name => base(type: 'belongs_to', name: name, filter: { filter => value }, **args) }
+      end
+
+      # Relación de uno a muchos, la relación recíproca es belongs_to
+      #
+      # @return [Hash]
+      def has_many_field(name:, filter:, value:, **args)
+        { name => base(type: 'has_many', name: name, filter: { filter => value }, **args) }
+      end
+
+      # Relación de muchos a muchos, la relación recíproca es
+      # has_and_belongs_to_many.
+      #
+      # @return [Hash]
+      def has_and_belongs_to_many_field(name:, filter:, value:, **args)
+        { name => base(type: 'has_and_belongs_to_many', name: name, filter: { filter => value }, **args) }
+      end
+
+      # Los tipos de campos válidos son los que esta clase define como
+      # métodos terminados en _field
+      #
+      # @return [Array]
+      def field_types
+        @field_types ||= self.public_methods.select do |m|
+          m.to_s.end_with? '_field'
+        end.map do |m|
+          m.to_s.sub(/_field\z/, '').to_sym
+        end.sort
+      end
+
+      # Valida si el tipo de campo está definido
+      #
+      # @param [String,Symbol]
+      # @return [Boolean]
+      def field_type?(type)
+        self.respond_to? :"#{type}_field"
+      end
+
+      # Devuelve un error si el tipo del campo no es válido
+      #
+      # @return [Nil]
+      def validate_field_type(type)
+        raise ArgumentError, "#{type} must be one of #{field_types.map(&:to_s).join(', ')}" unless field_type? type
+      end
+    end
+  end
+end