belt 0.0.7 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14240a12050757c9936f1f57d941d98d23f79d0fc82b54f3c9d75217a5a00677
-  data.tar.gz: d8c545b345c138d8d84ca2dc170ea99ad8b5404310620cdf17c8092263a2f7fc
+  metadata.gz: 9236fac00b7efcb43f17c02fb347626f768cf7dd5d6c1d2162470176043cdfde
+  data.tar.gz: d7998c44bfcdfa42eb4d22acca3fabf62e0005753b355f4112bbdff108682527
 SHA512:
-  metadata.gz: 6bf259163e8b4c50e4d544fc671f8ed5408b6996563392ff5301de7c5e26ac9098e149d0eeadae028fe455ef92e409e8c187130a6c12b2652673c77be7c6afae
-  data.tar.gz: 93bd5dc850ad6bb17e771c9a12982b4b89f2df06b048404f0b66dec83d7cff74720ee2e0e9359b00fb85341834b0c774faf51539afbec5c9fcbf01815eb7cf7d
+  metadata.gz: 3ec40527e1d14fe89e8e5f3dc412e803354630126d40e9bed1a8c1dc32703ecd5a1fbffec1690ff0262ee2d1ece1895751441fc554f2cc38b86cb1d36e8b4ea8
+  data.tar.gz: 3eaff9879994c9d2b7c3eb6b454a833bc4ae433bd544ac0c8fa3578045de96263a2871915b60d8707eaed8b512e497c88125554b45068d597d19d612a6b87209

data/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## 0.1.1
+
+### `belt routes` CLI command
+
+- Added `belt routes` — displays all routes defined in `infrastructure/routes.tf.rb`
+- Concise table output with VERB, PATH, CONTROLLER#ACTION (shows GATEWAY/LAMBDA columns when multiple namespaces exist)
+- JSON output via `--format json` includes routes array and optional schema models
+- Filter routes with `--grep PATTERN` (case-insensitive, matches verb, path, gateway, lambda, controller, or action)
+- Generate Ruby route manifest files with `--namespace NAMESPACE` (or `all` for every gateway/lambda)
+- `--output-dir DIR` controls where generated files are written (warns if used without `--namespace`)
+- Added `Belt.root` — project root detection by walking up to find `infrastructure/routes.tf.rb`, with fallback to `pwd`
+- Default output directory for generated routes: `#{Belt.root}/lambda/lib/routes`
+
+### `belt tasks` CLI command
+
+- Added `belt tasks` — lists available rake tasks from the project's Rakefile
+- Filter tasks with `--grep PATTERN`
+- Show all tasks (including undescribed) with `--all`
+- Run rake tasks directly: `belt lambda:build_layer` invokes `bundle exec rake lambda:build_layer`
+
+### Other changes
+
+- Added `Belt::RouteDSL` — full route DSL parser (resources, nested resources, scopes, mounts, schemas)
+- Added `Belt::TableInference` — infers DynamoDB table access from Terraform definitions
+- Renamed `TerraDispatch` references to `Belt` in templates and DSL entry points
+- Removed `activeitem` dependency from generated Gemfile template
+- Added Rakefile template to `belt new` scaffolding
+
 ## 0.0.7
 
 - Fixed `discover_gem_paths` to use `Gem.loaded_specs` instead of `Gem::Specification.each` — the latter silently returns nothing on Lambda's vendored bundle layout, causing gem controllers/models to not be found
@@ -26,4 +54,4 @@
 - Added `BeltController::Base` with callbacks, strong params, CORS, error handling
 - Added `ActionController::Parameters` (strong params without Rails)
 - Added response helpers and CORS origin resolution
-- Bundled dependencies: activeitem, lambda_loadout, s3arch
+- Bundled dependencies: activeitem, lambda_loadout

data/README.md

@@ -9,7 +9,6 @@ Belt bundles everything you need to go from zero to production:
 - **Belt::ActionRouter** — request routing to controllers from route manifests
 - **ActiveItem** — DynamoDB ORM (queries, validations, associations, transactions)
 - **Lambda Loadout** — structured logging, CloudWatch metrics (EMF), error alerting
-- **S3arch** — full-text search via SQLite FTS5, stored on S3, queried from Lambda
 
 ## Installation
 
@@ -129,7 +128,7 @@ terraform {
 Define routes in `infrastructure/routes.tf.rb`:
 
 ```ruby
-TerraDispatch.routes.draw do
+Belt.application.routes.draw do
   namespace :api do
     resources :posts, only: [:index, :show, :create]
   end
@@ -139,7 +138,7 @@ end
 Define tables in `infrastructure/schema.tf.rb`:
 
 ```ruby
-TerraDispatch.schema.define do
+Belt.application.schema.define do
   model :post do
     partition_key :id, :string
     global_secondary_index :UserIndex, partition_key: :user_id
@@ -201,80 +200,180 @@ error_response("Not found", 404)                        # 404 JSON error
 html_response("<h1>Hello</h1>")                         # 200 HTML with CORS
 ```
 
-## Holsters (Belt's Engines)
+## Controller Discovery
 
-Holsters are Belt's equivalent of Rails Engines. A holster lets a gem provide its own controllers, models, routes, and schema — all discovered automatically via convention.
+Belt discovers controllers from the app's namespace module first, then searches `Belt.all_controller_paths` — which includes app-defined paths. No registration needed.
 
-### Creating a Holster
+## Belt::Observability
 
-In your gem, subclass `Belt::Holster`:
+Belt provides global `Belt::Observability::Logger` and `Belt::Observability::Metrics` facades that are set automatically by `Belt::LambdaHandler`. Access them from anywhere:
 
 ```ruby
-# lib/s3arch/holster.rb
-module S3arch
-  class Holster < Belt::Holster
-  end
-end
+Belt::Observability::Logger.info("Something happened", user_id: "123")
+Belt::Observability::Metrics.track_event("OrderCreated", model: "Order")
+```
+
+## Environment Variables
+
+| Variable | Purpose |
+|----------|---------|
+| `ENVIRONMENT` | Controls verbose error responses (`dev*`, `local`, `test`) |
+| `BELT_METRICS_NAMESPACE` | CloudWatch metrics namespace (default: `Belt`) |
+| `ACTION` | Service name for logging (falls back to function name) |
+| `ERROR_NOTIFICATION_TOPIC_ARN` | SNS topic for error alerts |
+| `CORS_ALLOWED_ORIGINS` | Comma-separated origins (overrides domain vars) |
+| `CUSTOMER_APP_DOMAIN` | Primary app domain for CORS |
+| `OPS_APP_DOMAIN` | Internal tools domain for CORS |
+
+## CLI
+
+Belt includes a command-line interface for project management.
+
+### `belt routes`
+
+Display route definitions from your `infrastructure/routes.tf.rb`. This is the primary way to inspect what endpoints your app exposes.
+
+```bash
+belt routes
 ```
 
-That's it. Belt discovers all `Holster` subclasses at boot. By convention, it expects:
+Output (single namespace):
 
 ```
-your-gem/
-├── infrastructure/
-│   ├── routes.tf.rb      # Holster's route definitions
-│   └── schema.tf.rb      # Holster's DynamoDB tables
-└── lambda/
-    ├── controllers/      # Holster's controllers
-    └── models/           # Holster's models
+VERB    PATH                   CONTROLLER#ACTION
+------------------------------------------------------------------
+GET     /posts                 posts#index
+GET     /posts/{post_id}       posts#show
+POST    /posts                 posts#create
+DELETE  /posts/{post_id}       posts#destroy
 ```
 
-No configuration needed if you follow the convention. Belt resolves paths relative to your gem's root (two directories up from the holster file).
+When multiple namespaces (API Gateways) exist, GATEWAY and LAMBDA columns are added automatically:
 
-### Customizing Paths
+```
+VERB    PATH              GATEWAY  LAMBDA  CONTROLLER#ACTION
+---------------------------------------------------------------
+GET     /posts            blog     blog    posts#index
+POST    /posts            blog     blog    posts#create
+GET     /posts            ops      ops     posts#index
+POST    /posts            ops      ops     posts#create
+```
 
-If your gem uses a different layout, override any path:
+#### Options
 
-```ruby
-module MyGem
-  class Holster < Belt::Holster
-    self.gem_root = File.expand_path("..", __dir__)
-    self.controllers_path = File.join(gem_root, "app", "controllers")
-  end
-end
+| Flag | Description |
+|------|-------------|
+| `-g, --grep PATTERN` | Filter routes matching pattern (case-insensitive, matches verb, path, gateway, lambda, controller, or action) |
+| `-f, --format FORMAT` | Output format: `concise` (default) or `json` |
+| `--namespace NAMESPACE` | Generate Ruby route files for NAMESPACE (or "all") |
+| `--output-dir DIR` | Output directory for generated Ruby files (default: `lambda/lib/routes/`) |
+| `--schema FILE` | Path to `schema.tf.rb` for model definitions (default: same directory as routes file) |
+| `--tables-file FILE` | Path to Terraform file with `aws_dynamodb_table` resources for table inference |
+| `-h, --help` | Show help |
+
+#### Examples
+
+```bash
+# Filter routes by pattern
+belt routes -g posts
+
+# JSON output (for tooling/CI)
+belt routes -f json
+
+# Generate Ruby route constant for the "api" namespace
+belt routes --namespace api
+
+# Generate to a custom directory
+belt routes --namespace api --output-dir lib/routes
+
+# Include schema models in JSON output
+belt routes -f json --schema infrastructure/schema.tf.rb
+
+# Infer DynamoDB table access from Terraform
+belt routes -f json --tables-file infrastructure/main.tf
 ```
 
-### How Belt Uses Holsters
+#### JSON Output
+
+With `--format json`, the output includes a `routes` array and optionally a `models` array (when a schema file is found):
+
+```json
+{
+  "routes": [
+    {
+      "name": "posts",
+      "verb": "GET",
+      "path": "/posts",
+      "gateway": "api",
+      "lambda": "api",
+      "controller": "posts",
+      "action": "index",
+      "auth": "cognito",
+      "tables": ["posts"],
+      "request_model": "",
+      "response_model": ""
+    }
+  ],
+  "models": [
+    {
+      "name": "CreatePost",
+      "kind": "request",
+      "description": "Request model: CreatePost",
+      "properties": {
+        "title": { "type": "string" },
+        "body": { "type": "string" }
+      },
+      "required": ["title"]
+    }
+  ]
+}
+```
 
-- **Controllers**: `Belt::ActionRouter` searches holster controller paths automatically
-- **Routes**: `Belt.all_routes_paths` collects all holster `routes.tf.rb` files for the Terraform provider
-- **Schema**: `Belt.all_schema_paths` collects all holster `schema.tf.rb` files for the Terraform provider
-- **Models**: `Belt.all_models_paths` collects all holster model directories
+#### Ruby Output
 
-## Controller Discovery
+With `--namespace NAMESPACE`, Belt generates a frozen Ruby constant file at `lambda/lib/routes/<namespace>_routes.rb`:
 
-Belt discovers controllers from the app's namespace module first, then searches `Belt.all_controller_paths` — which includes both app-defined paths and holster-provided paths. No registration needed.
+```ruby
+# frozen_string_literal: true
+
+# Auto-generated by: belt routes --namespace api
+# Do not edit manually
+
+module Routes
+  API = [
+    {
+      verb: "GET",
+      path: "/posts",
+      gateway: "api",
+      lambda: "api",
+      controller: "posts",
+      action: "index",
+      auth: "cognito",
+      tables: ["posts"]
+    }
+  ].freeze
+end
+```
 
-## Belt::Observability
+This is used by `Belt::ActionRouter` at runtime for request routing.
 
-Belt provides global `Belt::Observability::Logger` and `Belt::Observability::Metrics` facades that are set automatically by `Belt::LambdaHandler`. Access them from anywhere:
+#### Route File Location
+
+The command expects `infrastructure/routes.tf.rb` in the current working directory. Routes are defined using the same DSL as the Belt Terraform provider:
 
 ```ruby
-Belt::Observability::Logger.info("Something happened", user_id: "123")
-Belt::Observability::Metrics.track_event("OrderCreated", model: "Order")
+Belt.application.routes.draw do
+  namespace :api do
+    resources :posts, only: [:index, :show, :create, :destroy]
+    resource :profile, only: [:show, :update]
+    get "health", action: :health
+  end
+end
 ```
 
-## Environment Variables
+#### Table Inference
 
-| Variable | Purpose |
-|----------|---------|
-| `ENVIRONMENT` | Controls verbose error responses (`dev*`, `local`, `test`) |
-| `BELT_METRICS_NAMESPACE` | CloudWatch metrics namespace (default: `Belt`) |
-| `ACTION` | Service name for logging (falls back to function name) |
-| `ERROR_NOTIFICATION_TOPIC_ARN` | SNS topic for error alerts |
-| `CORS_ALLOWED_ORIGINS` | Comma-separated origins (overrides domain vars) |
-| `CUSTOMER_APP_DOMAIN` | Primary app domain for CORS |
-| `OPS_APP_DOMAIN` | Internal tools domain for CORS |
+When `--tables-file` is provided, Belt parses `aws_dynamodb_table` resource blocks from your Terraform files and infers which tables each route accesses based on the resource name in the route path. Routes can also declare tables explicitly in the DSL via `tables: [:posts, :comments]`.
 
 ## License
 

data/exe/belt

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/belt/cli'
+
+Belt::CLI.start(ARGV)

data/lib/belt/action_router.rb

@@ -144,9 +144,15 @@ module Belt
         next unless File.exist?(full_path)
 
         require full_path
-        # After requiring, try to find the constant
+        # After requiring, try to find the constant (top-level or namespaced)
         class_name = "#{controller_name.split(%r{[_/]}).map(&:capitalize).join}Controller"
         return Object.const_get(class_name) if Object.const_defined?(class_name)
+
+        # Try under namespace module (e.g., BrablogControllers::PostsController)
+        if Object.const_defined?(@namespace_module_name)
+          ns = Object.const_get(@namespace_module_name)
+          return ns.const_get(class_name) if ns.const_defined?(class_name)
+        end
       end
 
       raise Belt::ActionNotFound, "Controller not found: #{controller_name}"

data/lib/belt/cli/app_detection.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Belt
+  module CLI
+    module AppDetection
+      def detect_app_name
+        routes_file = 'infrastructure/routes.tf.rb'
+        if File.exist?(routes_file)
+          match = File.read(routes_file).match(/namespace :(\w+)/)
+          return match[1] if match
+        end
+        File.basename(Dir.pwd)
+      end
+    end
+  end
+end

data/lib/belt/cli/bucket_security.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Belt
+  module CLI
+    module BucketSecurity
+      def audit_bucket_security(bucket)
+        {
+          versioning: check_versioning(bucket),
+          encryption: check_encryption(bucket),
+          public_access_block: check_public_access_block(bucket),
+          tls_policy: check_tls_policy(bucket)
+        }
+      end
+
+      def print_security_audit(audit)
+        puts "\nSecurity audit:"
+        puts "  #{audit[:versioning] ? '✓' : '✗'} Versioning"
+        puts "  #{audit[:encryption] ? '✓' : '✗'} Encryption (AES-256)"
+        puts "  #{audit[:public_access_block] ? '✓' : '✗'} Public access block"
+        puts "  #{audit[:tls_policy] ? '✓' : '✗'} TLS-only policy"
+      end
+
+      def check_versioning(bucket)
+        output = safe_capture('aws', 's3api', 'get-bucket-versioning', '--bucket', bucket, '--output', 'json')
+        return false unless output
+
+        data = JSON.parse(output)
+        data['Status'] == 'Enabled'
+      rescue JSON::ParserError
+        false
+      end
+
+      def check_encryption(bucket)
+        output = safe_capture('aws', 's3api', 'get-bucket-encryption', '--bucket', bucket, '--output', 'json')
+        return false unless output
+
+        data = JSON.parse(output)
+        rules = data.dig('ServerSideEncryptionConfiguration', 'Rules') || []
+        rules.any? { |r| r.dig('ApplyServerSideEncryptionByDefault', 'SSEAlgorithm') }
+      rescue JSON::ParserError
+        false
+      end
+
+      def check_public_access_block(bucket)
+        output = safe_capture('aws', 's3api', 'get-public-access-block', '--bucket', bucket, '--output', 'json')
+        return false unless output
+
+        data = JSON.parse(output)
+        config = data['PublicAccessBlockConfiguration'] || {}
+        config['BlockPublicAcls'] && config['IgnorePublicAcls'] &&
+          config['BlockPublicPolicy'] && config['RestrictPublicBuckets']
+      rescue JSON::ParserError
+        false
+      end
+
+      def check_tls_policy(bucket)
+        output = safe_capture('aws', 's3api', 'get-bucket-policy', '--bucket', bucket, '--output', 'json')
+        return false unless output
+
+        data = JSON.parse(output)
+        policy = JSON.parse(data['Policy'])
+        statements = policy['Statement'] || []
+        statements.any? do |s|
+          s['Effect'] == 'Deny' &&
+            s.dig('Condition', 'Bool', 'aws:SecureTransport') == 'false'
+        end
+      rescue JSON::ParserError, TypeError
+        false
+      end
+
+      def harden_bucket(bucket, audit)
+        unless audit[:versioning]
+          enable_versioning(bucket)
+          puts '  enable  versioning'
+        end
+        unless audit[:encryption]
+          enable_encryption(bucket)
+          puts '  enable  AES-256 encryption'
+        end
+        unless audit[:public_access_block]
+          block_public_access(bucket)
+          puts '  enable  public access block'
+        end
+        return if audit[:tls_policy]
+
+        apply_tls_policy(bucket)
+        puts '  enable  TLS-only bucket policy'
+      end
+
+      private
+
+      def enable_versioning(bucket)
+        run!('aws', 's3api', 'put-bucket-versioning', '--bucket', bucket,
+             '--versioning-configuration', 'Status=Enabled')
+      end
+
+      def enable_encryption(bucket)
+        config = '{"Rules":[{"ApplyServerSideEncryptionByDefault":{"SSEAlgorithm":"AES256"},"BucketKeyEnabled":true}]}'
+        run!('aws', 's3api', 'put-bucket-encryption', '--bucket', bucket,
+             '--server-side-encryption-configuration', config)
+      end
+
+      def block_public_access(bucket)
+        run!('aws', 's3api', 'put-public-access-block', '--bucket', bucket,
+             '--public-access-block-configuration',
+             'BlockPublicAcls=true,IgnorePublicAcls=true,BlockPublicPolicy=true,RestrictPublicBuckets=true')
+      end
+
+      def apply_tls_policy(bucket)
+        policy = {
+          Version: '2012-10-17',
+          Statement: [{
+            Sid: 'DenyInsecureConnections', Effect: 'Deny', Principal: '*', Action: 's3:*',
+            Resource: ["arn:aws:s3:::#{bucket}", "arn:aws:s3:::#{bucket}/*"],
+            Condition: { Bool: { 'aws:SecureTransport' => 'false' } }
+          }]
+        }
+        run!('aws', 's3api', 'put-bucket-policy', '--bucket', bucket, '--policy', JSON.generate(policy))
+      end
+    end
+  end
+end

data/lib/belt/cli/env_resolver.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Belt
+  module CLI
+    module EnvResolver
+      def self.resolve(args)
+        if args.first && !args.first.start_with?('-')
+          args.shift
+        else
+          ENV.fetch('BELT_ENV', nil)
+        end
+      end
+    end
+  end
+end

data/lib/belt/cli/environment_command.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'erb'
+require_relative 'app_detection'
+
+module Belt
+  module CLI
+    class EnvironmentCommand
+      TEMPLATE_DIR = File.expand_path('../../templates/environment', __dir__)
+
+      include AppDetection
+
+      def self.run(args)
+        env_name = args.shift
+
+        if env_name.nil? || env_name.empty?
+          puts 'Usage: belt generate environment <name>'
+          puts "\nExamples:"
+          puts '  belt generate environment dev01'
+          puts '  belt generate environment staging'
+          puts '  belt generate environment prod'
+          exit 1
+        end
+
+        new(env_name).generate
+      end
+
+      def initialize(env_name)
+        @env_name = env_name.downcase.gsub(/[^a-z0-9_-]/, '')
+        @app_name = detect_app_name
+      end
+
+      def generate
+        dest_dir = "infrastructure/#{@env_name}"
+
+        if Dir.exist?(dest_dir)
+          puts "Environment '#{@env_name}' already exists at #{dest_dir}/"
+          exit 1
+        end
+
+        puts "Creating environment: #{@env_name}"
+        FileUtils.mkdir_p(dest_dir)
+
+        templates.each do |template_name, dest_file|
+          dest_path = File.join(dest_dir, dest_file)
+          write_template(template_name, dest_path)
+          puts "  create  #{dest_path}"
+        end
+
+        puts "\n✓ Environment '#{@env_name}' created!"
+        puts "\nNext steps:"
+        puts "  cd #{dest_dir}"
+        puts '  terraform init'
+        puts '  terraform plan'
+        puts '  terraform apply'
+      end
+
+      private
+
+      def templates
+        {
+          'main.tf.erb' => 'main.tf',
+          'backend.tf.erb' => 'backend.tf',
+          'variables.tf.erb' => 'variables.tf',
+          'terraform.tfvars.erb' => 'terraform.tfvars'
+        }
+      end
+
+      def write_template(template_name, dest_path)
+        template_path = File.join(TEMPLATE_DIR, template_name)
+        content = ERB.new(File.read(template_path), trim_mode: '-').result(binding)
+        File.write(dest_path, content)
+      end
+    end
+  end
+end

data/lib/belt/cli/frontend_command.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'erb'
+require 'json'
+require_relative 'app_detection'
+
+module Belt
+  module CLI
+    class FrontendCommand
+      TEMPLATE_DIR = File.expand_path('../../templates/frontend', __dir__)
+      FRAMEWORKS = %w[react vue svelte].freeze
+
+      include AppDetection
+
+      def self.run(args)
+        framework = args.shift
+
+        if framework.nil? || !FRAMEWORKS.include?(framework)
+          puts "Usage: belt generate frontend <#{FRAMEWORKS.join('|')}>"
+          puts "\nScaffolds a frontend application with build tooling and API client."
+          puts "\nExamples:"
+          puts '  belt generate frontend react'
+          puts '  belt generate frontend vue'
+          exit 1
+        end
+
+        new(framework).generate
+      end
+
+      def initialize(framework)
+        @framework = framework
+        @app_name = detect_app_name
+        @module_name = @app_name.split(/[-_]/).map(&:capitalize).join
+      end
+
+      def generate
+        dest_dir = 'frontend'
+
+        if Dir.exist?(dest_dir) && !Dir.empty?(dest_dir)
+          puts "Directory 'frontend/' already exists and is not empty."
+          exit 1
+        end
+
+        puts "Creating #{@framework} frontend application..."
+        framework_dir = File.join(TEMPLATE_DIR, @framework)
+
+        unless Dir.exist?(framework_dir)
+          puts "✗ Template not found for '#{@framework}'. Available: #{FRAMEWORKS.join(', ')}"
+          exit 1
+        end
+
+        copy_template(framework_dir, dest_dir)
+
+        puts "\n✓ Frontend (#{@framework}) created in frontend/"
+        puts "\nNext steps:"
+        puts '  cd frontend && npm install && npm run dev'
+        puts '  belt setup frontend <env>    # Generate CloudFront + S3 infrastructure'
+        puts '  belt deploy frontend <env>   # Build and deploy to AWS'
+      end
+
+      private
+
+      def copy_template(src_dir, dest_dir)
+        Dir.glob("#{src_dir}/**/*", File::FNM_DOTMATCH).each do |src|
+          next if File.directory?(src)
+          next if src.end_with?('/..') || src.end_with?('/.')
+
+          rel_path = src.sub("#{src_dir}/", '')
+          dest_path = File.join(dest_dir, rel_path.sub(/\.erb\z/, ''))
+
+          FileUtils.mkdir_p(File.dirname(dest_path))
+
+          if src.end_with?('.erb')
+            content = ERB.new(File.read(src), trim_mode: '-').result(binding)
+            File.write(dest_path, content)
+          else
+            FileUtils.cp(src, dest_path)
+          end
+          puts "  create  #{dest_path}"
+        end
+      end
+    end
+  end
+end