shaf 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 33b4f2f8ba33dcc7d3f8abe950745897fca2439e
-  data.tar.gz: d677b6e4db2843c764027e91b00ee384a24baa60
+SHA256:
+  metadata.gz: 7ef999e9f5ceac2a21b21e33ae805a6f576bc1363c6cbd4622cbbbdf715e8252
+  data.tar.gz: '0030305862359ea34e55516b2d49abcd78c20eb1393ae9d99eabcb86d1b30de4'
 SHA512:
-  metadata.gz: 24eaf2fb8f70443206460d48853ea44d304c1616a65be60defb33147ee09e53923ee13b3563efc0ad00ce41976d7acd6048047d3b1f6d0323341fc9946900546
-  data.tar.gz: 7714930986d85adea752deb9bd7c200a3a7f06cb10826f4e39c9b066dd96b4fd58bae7e327c8fe8bc5e276ab781a9112e8d123e2787a4676fec09a06d10954fd
+  metadata.gz: 3ac44a36ff0d58fce2e7fb58d9f85187dc75e1077cc801f5fcfd637738be364619c3ccbb3d5ea28b0cd46319f258d36a6047f4c22f53564487a4af8652569ffd
+  data.tar.gz: d4bddad299a6236d0930d861a2fdc054531f5892c29cc9c2f5c918066d6943c0aa888b9e2fa346a7733784f2311da5845c475632c4641949711a8f0784546d15

data/lib/shaf/command/base.rb

@@ -0,0 +1,51 @@
+require 'optparse'
+require 'shaf/utils'
+
+module Shaf
+  module Command
+    class ArgumentError < CommandError; end
+
+    class Base
+      include Utils
+
+      attr_reader :args, :options
+
+      class << self
+        def inherited(child)
+          Factory.register(child)
+        end
+
+        def identifier(*ids)
+          @identifiers = ids.flatten
+        end
+
+        def usage(str = nil, &block)
+          @usage = str || block
+        end
+
+        def exit_with_error(msg, status)
+          STDERR.puts msg
+          exit status
+        end
+
+        def options(option_parser, options); end
+      end
+
+      def initialize(*args)
+        @args = args.dup
+        @options = {}
+        parse_options!
+      end
+
+      private
+
+      def parse_options!
+        parser = OptionParser.new
+        self.class.options(parser, @options)
+        parser.parse!(args)
+      rescue OptionParser::InvalidOption => e
+        raise ArgumentError, e.message
+      end
+    end
+  end
+end

data/lib/shaf/command/templates/Gemfile.erb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# A sample Gemfile
 source "https://rubygems.org"
 ruby '<%= RUBY_VERSION %>'
 

data/lib/shaf/command.rb

@@ -1,62 +1,16 @@
-require 'optparse'
-require 'shaf/utils'
 require 'shaf/registrable_factory'
 
 module Shaf
   module Command
-
     class CommandError < StandardError; end
-    class ArgumentError < CommandError; end
 
     class Factory
       extend RegistrableFactory
     end
-
-    class Base
-      include Utils
-
-      attr_reader :args, :options
-
-      class << self
-        def inherited(child)
-          Factory.register(child)
-        end
-
-        def identifier(*ids)
-          @identifiers = ids.flatten
-        end
-
-        def usage(str = nil, &block)
-          @usage = str || block
-        end
-
-        def exit_with_error(msg, status)
-          STDERR.puts msg
-          exit status
-        end
-
-        def options(option_parser, options); end
-      end
-
-      def initialize(*args)
-        @args = args.dup
-        @options = {}
-        parse_options!
-      end
-
-      private
-
-      def parse_options!
-        parser = OptionParser.new
-        self.class.options(parser, @options)
-        parser.parse!(args)
-      rescue OptionParser::InvalidOption => e
-        raise ArgumentError, e.message
-      end
-    end
   end
 end
 
+require 'shaf/command/base'
 require 'shaf/command/new'
 require 'shaf/command/upgrade'
 require 'shaf/command/server'

data/lib/shaf/extensions/resource_uris.rb

@@ -9,12 +9,7 @@ module Shaf
     end
 
     def register_uri(name, uri)
-      if UriHelper.respond_to? MethodBuilder.method_name(name)
-        raise "resource uri #{name} can't be registered. Method already exist!"
-      end
-      method_string = MethodBuilder.as_string(name, uri)
-      UriHelperMethods.eval_method(method_string)
-      UriHelperMethods.register(MethodBuilder.template_method_name(name)) { uri.dup.freeze }
+      MethodBuilder.new(name, uri).call
 
       include UriHelper unless self < UriHelper
     end
@@ -39,6 +34,13 @@ module Shaf
     def self.included(mod)
       mod.extend self
     end
+
+    def self.base_uri
+      protocol = Settings.protocol || 'http'
+      host = Settings.host || 'localhost'
+      port = Settings.port ? ":#{Settings.port}" : ""
+      "#{protocol}://#{host}#{port}"
+    end
   end
 
   # This class register uri helper methods like:
@@ -55,52 +57,10 @@ module Shaf
   #
   class CreateUriMethods
 
-    # Resources should never be nested more than 1 level deep.
-    MAX_NESTING_DEPTH = 1
-
-    class UriTemplateNestingError < StandardError
-      def initialize(msg = nil)
-        msg ||= "Uri templates only supports a nesting depth of #{MAX_NESTING_DEPTH}"
-        super(msg)
-      end
-    end
-
-    class UriTemplateVariableError < StandardError
-      def initialize(msg = nil)
-        msg ||= "Mismatch between uri templates and resources"
-        super(msg)
-      end
-    end
-
-    class << self
-      def resource_helper_uri(template_uri, *resources, query)
-        uri = replace_templates(template_uri, *resources)
-        query_string = MethodBuilder.query_string(query)
-        "#{uri}#{query_string}".freeze
-      end
-
-      def replace_templates(template_uri, *resources)
-        symbols = MethodBuilder.extract_symbols(template_uri)
-        resources.compact!
-        raise UriTemplateVariableError if symbols.size != resources.size
-
-        MethodBuilder.transform_symbols(template_uri) do |segment|
-          resrc = resources.shift
-          sym = symbols.shift
-          resrc.respond_to?(sym) ? resrc.public_send(sym) : resrc
-        end
-      end
-    end
-
     def initialize(name, base: nil, plural_name: nil)
       @name = name.to_s
       @base = base&.sub(%r(/\Z), '') || ''
       @plural_name = plural_name&.to_s || Utils::pluralize(name.to_s)
-
-      if nesting_depth > MAX_NESTING_DEPTH
-        raise UriTemplateNestingError,
-          "Too deep nesting level (max #{MAX_NESTING_DEPTH}): #{@base}"
-      end
     end
 
     def call
@@ -120,14 +80,12 @@ module Shaf
 
     def register_resources_uri
       template_uri = "#{base}/#{plural_name}".freeze
-      helper_name = "#{plural_name}_uri".freeze
-      register(template_uri, helper_name)
+      register(plural_name, template_uri)
     end
 
     def register_resource_uri
       template_uri = "#{base}/#{plural_name}/:id".freeze
-      helper_name = "#{name}_uri".freeze
-      register(template_uri, helper_name)
+      register(name, template_uri)
     end
 
     # If a resource has the same singular and plural names, then this method
@@ -136,137 +94,141 @@ module Shaf
     def register_resource_uri_by_arg
       resource_template_uri =   "#{base}/#{plural_name}/:id"
       collection_template_uri = "#{base}/#{plural_name}"
-      helper_name = "#{plural_name}_uri"
 
-      block = resource_or_collection_method_proc(resource_template_uri, collection_template_uri)
-      UriHelperMethods.register(helper_name, &block)
-      UriHelperMethods.register("#{helper_name}_template") do |collection = false|
-        (collection ? collection_template_uri : resource_template_uri).freeze
-      end
+      MethodBuilder.new(name, resource_template_uri, alt_uri: collection_template_uri).call
     end
 
     def register_new_resource_uri
       template_uri = "#{base}/#{plural_name}/form".freeze
-      helper_name = "new_#{name}_uri".freeze
-      register(template_uri, helper_name)
+      register("new_#{name}", template_uri)
     end
 
     def register_edit_resource_uri
       template_uri = "#{base}/#{plural_name}/:id/edit".freeze
-      helper_name = "edit_#{name}_uri".freeze
-      register(template_uri, helper_name)
+      register("edit_#{name}", template_uri)
     end
 
-    def register(template_uri, helper_name)
-      block = resource_helper_method_proc(template_uri)
-      UriHelperMethods.register(helper_name, &block)
-      UriHelperMethods.register("#{helper_name}_template") { template_uri }
+    def register(name, template_uri)
+      MethodBuilder.new(name, template_uri).call
     end
+  end
 
-    def resource_helper_method_proc(template_uri)
-      arg_count = MethodBuilder.extract_symbols(template_uri).size
+  class MethodBuilder
+    def self.query_string(query)
+      return "" unless query.any?
+      "?#{query.map { |key,value| "#{key}=#{value}" }.join("&")}"
+    end
 
-      case arg_count
-      when 0
-        ->(**query) do
-          CreateUriMethods.resource_helper_uri(template_uri, query)
-        end
-      when 1
-        ->(resrc, **query) do
-          CreateUriMethods.resource_helper_uri(template_uri, resrc, query)
-        end
-      when 2
-        ->(parent_resrc, resrc, **query) do
-          CreateUriMethods.resource_helper_uri(template_uri, parent_resrc, resrc, query)
-        end
-      else
-        raise UriTemplateNestingError,
-          "Too deep nesting level (max #{MAX_NESTING_DEPTH}): #{template_uri}"
-      end
+    def initialize(name, uri, alt_uri: nil)
+      @name = name
+      @uri = uri
+      @alt_uri = alt_uri
     end
 
-    def resource_or_collection_method_proc(resource_template_uri, collection_template_uri)
-      case nesting_depth
-      when 0
-        ->(resrc = nil, **query) {
-          args = if resrc.nil?
-                   [collection_template_uri, query]
-                 else
-                   [resource_template_uri, resrc, query]
-                 end
-          CreateUriMethods.resource_helper_uri(*args)
-        }
-      when 1
-        ->(parent_resrc, resrc = nil, **query) {
-          args = if resrc.nil?
-                   [collection_template_uri, parent_resrc, query]
-                 else
-                   [resource_template_uri, parent_resrc, resrc, query]
-                 end
-          CreateUriMethods.resource_helper_uri(*args)
-        }
+    def call
+      if UriHelper.respond_to? method_name
+        raise "resource uri #{@name} can't be registered. " \
+          "Method :#{method_name} already exist!"
+      end
+
+      if @alt_uri.nil?
+        build_methods
       else
-        raise UriTemplateNestingError,
-          "Too deep nesting level (max #{MAX_NESTING_DEPTH}): #{template_uri}"
+        build_methods_with_optional_arg
       end
     end
 
-    def nesting_depth
-      MethodBuilder.extract_symbols(base).size
+    private
+
+    def build_methods
+      UriHelperMethods.eval_method method_string
+      UriHelperMethods.register(template_method_name, &template_proc)
     end
-  end
 
-  module MethodBuilder
-    class << self
-      def method_name(name)
-        "#{name}_uri"
-      end
+    def build_methods_with_optional_arg
+      UriHelperMethods.eval_method method_with_optional_arg_string
+      UriHelperMethods.register(template_method_name, &template_proc)
+    end
 
-      def template_method_name(name)
-        "#{method_name(name)}_template"
-      end
+    def method_name
+      "#{@name}_uri".freeze
+    end
 
-      def signature(name, uri)
-        args = extract_symbols(uri)
-        s = "#{method_name(name)}("
-        s << (args.empty? ? "**query)" : "#{args.join(', ')}, **query)")
-      end
+    def template_method_name
+      "#{method_name}_template".freeze
+    end
 
-      def query_string(query)
-        return "" unless query.any?
-        "?#{query.map { |key,value| "#{key}=#{value}" }.join("&")}"
-      end
+    def signature(optional_args: 0)
+      s = "#{method_name}("
 
-      def as_string(name, uri)
-        signature = signature(name, uri)
-        <<~Ruby
-      def #{signature}
-        query_string = MethodBuilder.query_string(query)
-        \"#{interpolated_uri_string(uri)}\#{query_string}\".freeze
-      end
-        Ruby
-      end
+      symbols = extract_symbols.size.times.map { |i| "arg#{i}" }
+      sym_count = symbols.size
 
-      def extract_symbols(uri)
-        uri.split('/').grep(/:.*/).map { |t| t[1..-1] }.map(&:to_sym)
+      args = []
+      symbols.each_with_index do |arg, i|
+        if i < sym_count - optional_args
+          args << "arg#{i}"
+        else
+          args << "arg#{i} = nil"
+        end
       end
+      s << (args.empty? ? "**query)" : "#{args.join(', ')}, **query)")
+    end
 
-      def transform_symbols(uri)
-        uri.split('/').map do |segment|
-          next segment unless segment.start_with? ':'
-          yield segment
-        end.join('/')
-      end
+    def method_string
+      base_uri = UriHelper.base_uri
+      <<~Ruby
+        def #{signature}
+          query_str = Shaf::MethodBuilder.query_string(query)
+          \"#{base_uri}#{interpolated_uri_string(@uri)}\#{query_str}\".freeze
+        end
+      Ruby
+    end
+
+    def method_with_optional_arg_string
+      base_uri = UriHelper.base_uri
+      arg_no = extract_symbols.size - 1
+      <<~Ruby
+        def #{signature(optional_args: 1)}
+          query_str = Shaf::MethodBuilder.query_string(query)
+          if arg#{arg_no}.nil?
+            \"#{base_uri}#{interpolated_uri_string(@alt_uri)}\#{query_str}\".freeze
+          else
+            \"#{base_uri}#{interpolated_uri_string(@uri)}\#{query_str}\".freeze
+          end
+        end
+      Ruby
+    end
+
+    def extract_symbols(uri = @uri)
+      uri.split('/').grep(/:.*/).map { |t| t[1..-1].to_sym }
+    end
 
-      private
+    def transform_symbols(uri)
+      i = -1
+      uri.split('/').map do |segment|
+        next segment unless segment.start_with? ':'
+        i += 1
+        yield segment, i
+      end.join('/')
+    end
 
-      def interpolated_uri_string(uri)
-        return uri if uri == '/'
+    def interpolated_uri_string(uri)
+      return uri if uri == '/'
 
-        transform_symbols(uri) do |segment|
-          str = segment[1..-1]
-          "\#{#{str}.respond_to?(#{segment}) ? #{str}.#{str} : #{str}}"
-        end
+      transform_symbols(uri) do |segment, i|
+        sym = segment[1..-1]
+        "\#{arg#{i}.respond_to?(#{segment}) ? arg#{i}.#{sym} : arg#{i}}"
+      end
+    end
+
+    def template_proc
+      uri, alt_uri = @uri, @alt_uri
+
+      if alt_uri.nil?
+        -> { uri.freeze }
+      else
+        ->(collection = false) { collection ? alt_uri : uri }
       end
     end
   end

data/lib/shaf/generator/base.rb

@@ -0,0 +1,61 @@
+require 'fileutils'
+require 'erb'
+require 'ostruct'
+
+module Shaf
+  module Generator
+    class Base
+      attr_reader :args
+
+      class << self
+        def inherited(child)
+          Factory.register(child)
+        end
+
+        def identifier(*ids)
+          @identifiers = ids.flatten
+        end
+
+        def usage(str = nil, &block)
+          @usage = str || block
+        end
+
+        def options(option_parser, options); end
+      end
+
+      def initialize(*args)
+        @args = args.dup
+      end
+
+      def call(options = {}); end
+
+      def template_dir
+        File.expand_path('../templates', __FILE__)
+      end
+
+      def read_template(file, directory = nil)
+        directory ||= template_dir
+        filename = File.join(directory, file)
+        filename << ".erb" unless filename.end_with?(".erb")
+        File.read(filename)
+      end
+
+      def render(template, locals = {})
+        str = read_template(template)
+        locals[:changes] ||= []
+        b = OpenStruct.new(locals).instance_eval { binding }
+        ERB.new(str, 0, '%-<>').result(b)
+      rescue SystemCallError => e
+        puts "Failed to render template #{template}: #{e.message}"
+        raise
+      end
+
+      def write_output(file, content)
+        dir = File.dirname(file)
+        FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+        File.write(file, content)
+        puts "Added:      #{file}"
+      end
+    end
+  end
+end

data/lib/shaf/generator/migration/base.rb

@@ -0,0 +1,133 @@
+require 'date'
+
+module Shaf
+  module Generator
+    module Migration
+      class Base
+        DB_COL_FORMAT_STRINGS = {
+          integer:    ['Integer :%s',             'add_column :%s, Integer'],
+          varchar:    ['String %s',               'add_column :%s, String'],
+          string:     ['String :%s',              'add_column :%s, String'],
+          text:       ['String :%s, text: true',  'add_column :%s, String, text: true'],
+          blob:       ['File :%s',                'add_column :%s, File'],
+          bigint:     ['Bignum :%s',              'add_column :%s, Bignum'],
+          double:     ['Float :%s',               'add_column :%s, Float'],
+          numeric:    ['BigDecimal :%s',          'add_column :%s, BigDecimal'],
+          date:       ['Date :%s',                'add_column :%s, Date'],
+          timestamp:  ['DateTime :%s',            'add_column :%s, DateTime'],
+          time:       ['Time :%s',                'add_column :%s, Time'],
+          bool:       ['TrueClass :%s',           'add_column :%s, TrueClass'],
+          boolean:    ['TrueClass :%s',           'add_column :%s, TrueClass'],
+          index:      ['index :%s, unique: true', 'add_index :%s'],
+        }
+
+        COMPLEX_DB_TYPES = [
+          {
+            pattern: /\Aforeign_key\((\w+)\)/,
+            strings: ['foreign_key :%s, :\1',     'add_foreign_key :%s, :\1'],
+            validator: ->(type, match) {
+              break if ::DB.table_exists?(match[1])
+              ["Foreign key table '#{match[1]}' does not exist!"]
+            }
+          }
+        ]
+
+        attr_reader :args
+
+        class << self
+          def inherited(child)
+            Factory.register(child)
+          end
+
+          def identifier(*ids)
+            @identifiers = ids.flatten.map(&:to_s)
+          end
+
+          def usage(str = nil, &block)
+            @usage = str || block
+          end
+        end
+
+        def initialize(*args)
+          @args = args.dup
+        end
+
+        def call
+          validate_args
+          name = compile_migration_name
+          compile_changes
+          [target(name), render]
+        rescue StandardError => e
+          raise Command::ArgumentError, e.message
+        end
+
+        def add_change(change)
+          @changes ||= []
+          @changes << change if change
+        end
+
+        def column_def(str, create: true)
+          name, type = str.split(':')
+          format_string = db_format_string(type, create ? 0 : 1)
+          format format_string, name.downcase
+        end
+
+        def target(name)
+          raise "Migration filename is nil" unless name
+          "db/migrations/#{timestamp}_#{name}.rb"
+        end
+
+        private
+
+        def timestamp
+          DateTime.now.strftime("%Y%m%d%H%M%S")
+        end
+
+        def add_timestamp_columns?
+          if File.exist? 'config/initializers/sequel.rb'
+            require 'config/initializers/sequel'
+            Sequel::Model.plugins.include? Sequel::Plugins::Timestamps
+          end
+        end
+
+        def db_format_string(type, range = 0..1)
+          type ||= :string
+          result = DB_COL_FORMAT_STRINGS[type.to_sym]
+          result ||= regexp_db_format_string(type)
+          raise "Column type '#{type}' not supported" unless result
+          result[range]
+        end
+
+        def regexp_db_format_string(type)
+          COMPLEX_DB_TYPES.each do |complex_type|
+            match = complex_type[:pattern].match(type) or next
+            validator = complex_type[:validator]
+            errors = validator&.call(type, match)
+            if errors.nil? || errors.empty?
+              return complex_type[:strings].map { |s| replace_backreferences(match, s) }
+            end
+            raise "Failed to process '#{type}': #{errors.join(', ')}"
+          end
+        end
+
+        def replace_backreferences(match, str)
+          groups = match.size
+          (1...groups).inject(str) do |s, i|
+            s.gsub("\\#{i}", match[i])
+          end
+        end
+
+        def render
+          <<~EOS
+            Sequel.migration do
+              change do
+                #{@changes.flatten.join("\n    ")}
+              end
+            end
+          EOS
+        end
+      end
+
+    end
+  end
+end

data/lib/shaf/generator/migration/create_table.rb

@@ -11,14 +11,14 @@ module Shaf
           raise "Please provide a table name when generation a create table migration"
         end
 
-        def compile_migration_name
-          "create_#{table_name}_table"
-        end
-
         def table_name
           args.first || ""
         end
 
+        def compile_migration_name
+          "create_#{table_name}_table"
+        end
+
         def compile_changes
           add_change create_table_change
         end