scaffold_sinatra 0.0.4 → 0.0.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: 96399919c6387b2f6ec903a60592cf829e7237ef
4
- data.tar.gz: ac43e7731424075a18ac7f854b4dc5d00b6dfa4a
3
+ metadata.gz: f4b6d2860c6f892b20e6d74b203b3d6550e357de
4
+ data.tar.gz: 5b8df13d4c567411b02920b5eb71c3cd34e8f534
5
5
  SHA512:
6
- metadata.gz: 49c4ad40f25b093132430f2f5420687b57eb68d58e076646cf9022f67028fe3a475f84f6dbd55f56c15ac52f810d3e1230f72223077fd6c8bca6867112a340b2
7
- data.tar.gz: 9bc6399f63852e22f5328b68356653dd3866fe3d5093555e069af7f446ed62d0493a2319d738bdabae39f692f71d91dbd717992dc86548614bb418be324651f6
6
+ metadata.gz: 5763a586c9351eb3b0fb700c8ba08ae0e99b2a448b4873d573e36bb6c55bf3137836c76b9eefec59f02666a98185a34c19c181fc787c62d126c403fdd85a1187
7
+ data.tar.gz: 8b783baeafa27c7fc5445ce7f596896f4b7ad6bae021d75f7cdcc8d28bec28db73dc8aa64c7621636ceef305e1609ecb3ec1b5112ad4aecdb2485a0ecfebade5
data/Gemfile CHANGED
@@ -1,4 +0,0 @@
1
- source 'https://rubygems.org'
2
-
3
- # Specify your gem's dependencies in scaffold_sinatra.gemspec
4
- gemspec
data/app.rb ADDED
File without changes
data/bin/scaffold_sinatra CHANGED
@@ -1,37 +1,79 @@
1
1
  #!/usr/bin/env ruby
2
2
 
3
+ require 'active_support/inflector'
3
4
  require 'fileutils'
4
5
  require 'pathname'
5
6
  require 'open-uri'
6
7
  require 'colorize'
7
8
  require 'erb'
8
- require 'pry'
9
+
10
+ require 'pry' # TODO remove!
11
+
12
+ $LOAD_PATH.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
13
+ require 'scaffold_sinatra'
14
+ require 'trollop'
9
15
 
10
16
  DATA_PATH = File.expand_path("../../data", __FILE__)
11
17
 
18
+ include ScaffoldSinatra::Utils
12
19
  include FileUtils
13
20
 
21
+
22
+
23
+ ######################
24
+ # Parse options and set environment
25
+ ######################
26
+
27
+ opts = Trollop::options do
28
+ version("ScaffoldSinatra #{ScaffoldSinatra::VERSION}")
29
+ # originally used 'version', but this caused major namespace confusions...
30
+ opt :level, "Set scaffold level: 'basic', 'standard', or 'full'.", type: :string, default: "full"
31
+ end
32
+
33
+ if is_scaffold?(opts[:level])
34
+ self.scaffold = opts[:level]
35
+ else
36
+ puts "There is no scaffold named '#{opts[:level]}.' See `scaffold_sinatra -h`.".red
37
+ exit
38
+ end
39
+
40
+ ######################
41
+ # Ensure project name
42
+ ######################
43
+
14
44
  project_name = ARGV[0]
15
45
 
16
- # check input
17
46
  if project_name.nil?
18
47
  puts "Can't build project without name.".red
19
48
  exit
20
- elsif Dir.exist?(project_name)
21
- puts "#{project_name} already exists!".red
49
+ end
50
+
51
+ # it's a naming thing
52
+ project_snake_case = project_name.underscore
53
+ project_camel_case = project_snake_case.camelize
54
+ project_title_case = project_snake_case.titleize
55
+
56
+ # check input
57
+ if Dir.exist?(project_snake_case)
58
+ puts "#{project_snake_case} already exists!".red
22
59
  exit
23
60
  end
24
61
 
62
+ ######################
63
+ # Run scaffold
64
+ ######################
65
+
25
66
  # make app repo
26
- mkdir(project_name)
67
+ mkdir(project_snake_case)
27
68
 
28
69
  # and do all the work there...
29
- cd(project_name) do
70
+ cd(project_snake_case) do
30
71
 
31
72
  # copy data directory over
32
73
  data_root = Pathname.new(DATA_PATH)
33
- Dir.glob(File.join(DATA_PATH, "**/*")).each do |data_file_path|
74
+ Dir.glob(File.join(DATA_PATH, "**/{*,.*}")).each do |data_file_path|
34
75
  relative_file_path = Pathname.new(data_file_path).relative_path_from(data_root)
76
+ next if !include_in_scaffold?(relative_file_path)
35
77
 
36
78
  # make directories as necessary
37
79
  if File.directory?(data_file_path)
@@ -50,15 +92,17 @@ cd(project_name) do
50
92
  end
51
93
  end
52
94
 
95
+ # FIXME fails when not connected to internet
96
+
53
97
  # copy files from internet
54
98
  File.open('public/stylesheets/normalize.css', 'w+') do |f|
55
99
  normalize_url = 'https://raw.githubusercontent.com/necolas/normalize.css/master/normalize.css'
56
100
  f.write(open(normalize_url).read)
57
101
  end
58
102
 
59
- system('bundle install')
103
+ system('bundle install') if standard_scaffold?
60
104
 
61
105
  puts('>> OK!'.white)
62
- puts(">> Created #{project_name}!".green)
106
+ puts(">> Created #{project_snake_case}!".green)
63
107
  puts('>> use `bundle exec shotgun -p 3000` from inside the folder to run it!')
64
108
  end
data/config.ru ADDED
File without changes
data/data/.env ADDED
@@ -0,0 +1,9 @@
1
+
2
+ # Keep it secret, keep it safe!
3
+
4
+ # Here is an example:
5
+
6
+ # #============ Amazon S3 ===============
7
+ # export S3_BUCKET=YOURS3BUCKET
8
+ # export SECRET_KEY=YOURSECRETKEYGOESHERE
9
+ #
data/data/.gitignore ADDED
@@ -0,0 +1,2 @@
1
+ # do not upload our application's secrets!
2
+ .env
data/data/Gemfile.erb CHANGED
@@ -1,13 +1,15 @@
1
1
  source 'https://rubygems.org'
2
2
 
3
- ruby "<%= RUBY_VERSION %>"
3
+ ruby '<%= RUBY_VERSION %>'
4
4
 
5
5
  # Gems used in every environment
6
6
  gem 'sinatra', '1.4.5'
7
+ <%= "gem 'dotenv', '~> 0.9.0'" if full_scaffold? %>
7
8
 
8
9
  # gems specific to the development environment
9
10
  group :development do
10
- gem 'shotgun', '0.9'
11
+ gem 'sinatra-contrib', '~> 1.4.2', require: 'sinatra/reloader'
12
+ gem 'rake', '~> 10.3.2'
11
13
  end
12
14
 
13
15
  # gems specifically for testing
data/data/Rakefile CHANGED
@@ -1,6 +1,6 @@
1
- desc "start Sinatra server with `shotgun` command on port 3000."
1
+ desc "start Sinatra server with `rackup` command on port 3000."
2
2
  task :start do
3
- `bundle exec shotgun -p 3000`
3
+ `bundle exec rackup -p 3000`
4
4
  end
5
5
 
6
6
  task :default => 'start'
data/data/app.rb.erb CHANGED
@@ -1,29 +1,47 @@
1
- class App < Sinatra::Base
1
+ <% if full_scaffold? %>
2
+ require File.expand_path('../boot', __FILE__)
2
3
 
3
- ########################
4
- # Configuration
5
- ########################
4
+ <% end %>
5
+ module <%= project_camel_case %>
6
+ class App < Sinatra::Base
6
7
 
7
- # allow simple "logging" of server output
8
- enable :logging
8
+ ########################
9
+ # Configuration
10
+ ########################
9
11
 
10
- # allow put/delete forms in browsers that don't support it
11
- enable :method_override
12
+ # allow simple "logging" of server output
13
+ enable :logging
12
14
 
13
- # store data between HTTP requests in a cookie
14
- enable :sessions
15
+ <% if standard_scaffold? %>
16
+ # allow put/delete forms in browsers that don't support it
17
+ enable :method_override
15
18
 
16
- # we can set the session's cookie hash ourselves, so that all of our app's
17
- # instances share it: since we want to run shotgun, which creates new
18
- # application instances, we must manually set session_secret
19
- set :session_secret, SecureRandom.urlsafe_base64
19
+ # store data between HTTP requests in a cookie
20
+ enable :sessions
20
21
 
21
- ########################
22
- # Routes
23
- ########################
24
-
25
- get('/') do
26
- render(:erb, :index)
27
- end
22
+ <%#
23
+ # TODO figure out if we need to have ses_secret, and if so, whether
24
+ we should put it into a config development group or somewhere else...
25
+ %>
26
+ # we can set the session's cookie hash ourselves, so that all of our app's
27
+ # instances share it: since we want to run shotgun, which creates new
28
+ # application instances, we must manually set session_secret
29
+ set :session_secret, SecureRandom.urlsafe_base64
30
+
31
+ # include the use of auto-reloading when in development
32
+ configure :development do
33
+ require "sinatra/reloader"
34
+ register Sinatra::Reloader
35
+ end
36
+
37
+ <% end %>
38
+ ########################
39
+ # Routes
40
+ ########################
28
41
 
42
+ get('/') do
43
+ render(:erb, :index)
44
+ end
45
+
46
+ end
29
47
  end
data/data/boot.rb ADDED
@@ -0,0 +1,13 @@
1
+
2
+ # Include below all of the necessary configurations and actions
3
+ # to set up the environment and load dependencies, constants,
4
+ # and helpers. Initializes the application!
5
+
6
+ # load environmental variables
7
+ require "dotenv"
8
+ Dotenv.load
9
+
10
+ # load files in /helpers
11
+ Dir.glob(File.join("helpers", "**", "*.rb")).each do |helper|
12
+ require_relative helper
13
+ end
data/data/config.ru.erb CHANGED
@@ -1,7 +1,9 @@
1
+ <% if standard_scaffold? %>
1
2
  require 'rubygems'
2
3
  require 'bundler'
3
4
 
4
5
  Bundler.require(:default, ENV['RACK_ENV'])
5
6
 
7
+ <% end %>
6
8
  require './app'
7
- run App
9
+ run <%= project_camel_case %>::App
Binary file
@@ -0,0 +1,3 @@
1
+ # <%= project_title_case %>
2
+
3
+ *Todo...*
@@ -1,2 +1,2 @@
1
1
  <h1 class="ga-banner">Hello World!</h1>
2
- <img src="/images/GA-logo-small.png" style="display: block; margin: 10px auto;"/>
2
+ <img src="/images/ga-logo-small.png" style="display: block; margin: 10px auto;"/>
@@ -4,11 +4,11 @@
4
4
  <head>
5
5
  <meta charset="utf-8">
6
6
 
7
- <title><%= project_name.capitalize %></title>
7
+ <title><%= project_title_case %></title>
8
8
 
9
9
  <meta name="description" content="">
10
10
  <meta name="viewport" content="width=device-width, initial-scale=1">
11
-
11
+ <link href="/images/ga-favicon.ico" rel="icon">
12
12
  <link href="/stylesheets/normalize.css" rel="stylesheet" type="text/css" media="all">
13
13
  <link href="/stylesheets/style.css" rel="stylesheet" type="text/css" media="all">
14
14
  </head>
@@ -0,0 +1,44 @@
1
+ module ScaffoldSinatra
2
+ module Scaffolds
3
+ BASIC = 1
4
+ STANDARD = 2
5
+ FULL = 3
6
+
7
+ FILE_SCAFFOLD = {
8
+ "app.rb.erb" => "basic",
9
+ "config.ru.erb" => "basic",
10
+ "public" => "basic",
11
+ "public/images" => "basic",
12
+ "public/images/ga-favicon.ico" => "basic",
13
+ "public/images/ga-logo-small.png" => "basic",
14
+ "public/stylesheets" => "basic",
15
+ "public/stylesheets/style.css.erb" => "basic",
16
+ "readme.md.erb" => "basic",
17
+ "views" => "basic",
18
+ "views/index.erb.erb" => "basic",
19
+ "views/layout.erb.erb" => "basic",
20
+ "Gemfile.erb" => "standard",
21
+ "Rakefile" => "standard",
22
+ "boot.rb" => "full",
23
+ "helpers" => "full",
24
+ ".env" => "full",
25
+ ".gitignore" => "full"
26
+ }
27
+
28
+ def scaffolds
29
+ context = ScaffoldSinatra::Scaffolds
30
+ @@scaffolds ||= context.constants.reduce({}) do |hash, constant|
31
+ hash[constant.to_s.downcase] = context.const_get(constant)
32
+ hash
33
+ end
34
+ end
35
+
36
+ def value_of(scaffold)
37
+ scaffolds[scaffold]
38
+ end
39
+
40
+ def scaffold_with_value(value)
41
+ scaffolds.key(value)
42
+ end
43
+ end
44
+ end
@@ -0,0 +1,34 @@
1
+ require_relative 'scaffolds'
2
+
3
+ module ScaffoldSinatra
4
+ module Utils
5
+ include ScaffoldSinatra::Scaffolds
6
+
7
+ def self.add_scaffold_methods
8
+ module_function(:scaffolds)
9
+ scaffolds.each_key do |level_of|
10
+ level = const_get(level_of.upcase)
11
+ define_method(:"#{level_of}_scaffold?") { @value >= level }
12
+ end
13
+ end
14
+
15
+ add_scaffold_methods
16
+
17
+ def scaffold=(scaffold)
18
+ @value = value_of(scaffold)
19
+ end
20
+
21
+ def scaffold
22
+ scaffold_with_value(@value)
23
+ end
24
+
25
+ def is_scaffold?(scaffold)
26
+ !ScaffoldSinatra::Scaffolds.const_get(scaffold.upcase).nil?
27
+ end
28
+
29
+ def include_in_scaffold?(file_name)
30
+ scaffold = ScaffoldSinatra::Scaffolds::FILE_SCAFFOLD[file_name.to_s]
31
+ ScaffoldSinatra::Scaffolds.const_get(scaffold.upcase) <= @value
32
+ end
33
+ end
34
+ end
@@ -1,3 +1,3 @@
1
1
  module ScaffoldSinatra
2
- VERSION = "0.0.4"
2
+ VERSION = "0.0.5"
3
3
  end
@@ -1,5 +1,6 @@
1
1
  require "scaffold_sinatra/version"
2
+ require "scaffold_sinatra/utils"
2
3
 
3
4
  module ScaffoldSinatra
4
- # Your code goes here...
5
+
5
6
  end
data/lib/trollop.rb ADDED
@@ -0,0 +1,782 @@
1
+ ## lib/trollop.rb -- trollop command-line processing library
2
+ ## Author:: William Morgan (mailto: wmorgan-trollop@masanjin.net)
3
+ ## Copyright:: Copyright 2007 William Morgan
4
+ ## License:: the same terms as ruby itself
5
+
6
+ require 'date'
7
+
8
+ module Trollop
9
+
10
+ VERSION = "1.16.2"
11
+
12
+ ## Thrown by Parser in the event of a commandline error. Not needed if
13
+ ## you're using the Trollop::options entry.
14
+ class CommandlineError < StandardError; end
15
+
16
+ ## Thrown by Parser if the user passes in '-h' or '--help'. Handled
17
+ ## automatically by Trollop#options.
18
+ class HelpNeeded < StandardError; end
19
+
20
+ ## Thrown by Parser if the user passes in '-h' or '--version'. Handled
21
+ ## automatically by Trollop#options.
22
+ class VersionNeeded < StandardError; end
23
+
24
+ ## Regex for floating point numbers
25
+ FLOAT_RE = /^-?((\d+(\.\d+)?)|(\.\d+))([eE][-+]?[\d]+)?$/
26
+
27
+ ## Regex for parameters
28
+ PARAM_RE = /^-(-|\.$|[^\d\.])/
29
+
30
+ ## The commandline parser. In typical usage, the methods in this class
31
+ ## will be handled internally by Trollop::options. In this case, only the
32
+ ## #opt, #banner and #version, #depends, and #conflicts methods will
33
+ ## typically be called.
34
+ ##
35
+ ## If you want to instantiate this class yourself (for more complicated
36
+ ## argument-parsing logic), call #parse to actually produce the output hash,
37
+ ## and consider calling it from within
38
+ ## Trollop::with_standard_exception_handling.
39
+ class Parser
40
+
41
+ ## The set of values that indicate a flag option when passed as the
42
+ ## +:type+ parameter of #opt.
43
+ FLAG_TYPES = [:flag, :bool, :boolean]
44
+
45
+ ## The set of values that indicate a single-parameter (normal) option when
46
+ ## passed as the +:type+ parameter of #opt.
47
+ ##
48
+ ## A value of +io+ corresponds to a readable IO resource, including
49
+ ## a filename, URI, or the strings 'stdin' or '-'.
50
+ SINGLE_ARG_TYPES = [:int, :integer, :string, :double, :float, :io, :date]
51
+
52
+ ## The set of values that indicate a multiple-parameter option (i.e., that
53
+ ## takes multiple space-separated values on the commandline) when passed as
54
+ ## the +:type+ parameter of #opt.
55
+ MULTI_ARG_TYPES = [:ints, :integers, :strings, :doubles, :floats, :ios, :dates]
56
+
57
+ ## The complete set of legal values for the +:type+ parameter of #opt.
58
+ TYPES = FLAG_TYPES + SINGLE_ARG_TYPES + MULTI_ARG_TYPES
59
+
60
+ INVALID_SHORT_ARG_REGEX = /[\d-]/ #:nodoc:
61
+
62
+ ## The values from the commandline that were not interpreted by #parse.
63
+ attr_reader :leftovers
64
+
65
+ ## The complete configuration hashes for each option. (Mainly useful
66
+ ## for testing.)
67
+ attr_reader :specs
68
+
69
+ ## Initializes the parser, and instance-evaluates any block given.
70
+ def initialize *a, &b
71
+ @version = nil
72
+ @leftovers = []
73
+ @specs = {}
74
+ @long = {}
75
+ @short = {}
76
+ @order = []
77
+ @constraints = []
78
+ @stop_words = []
79
+ @stop_on_unknown = false
80
+
81
+ #instance_eval(&b) if b # can't take arguments
82
+ cloaker(&b).bind(self).call(*a) if b
83
+ end
84
+
85
+ ## Define an option. +name+ is the option name, a unique identifier
86
+ ## for the option that you will use internally, which should be a
87
+ ## symbol or a string. +desc+ is a string description which will be
88
+ ## displayed in help messages.
89
+ ##
90
+ ## Takes the following optional arguments:
91
+ ##
92
+ ## [+:long+] Specify the long form of the argument, i.e. the form with two dashes. If unspecified, will be automatically derived based on the argument name by turning the +name+ option into a string, and replacing any _'s by -'s.
93
+ ## [+:short+] Specify the short form of the argument, i.e. the form with one dash. If unspecified, will be automatically derived from +name+.
94
+ ## [+:type+] Require that the argument take a parameter or parameters of type +type+. For a single parameter, the value can be a member of +SINGLE_ARG_TYPES+, or a corresponding Ruby class (e.g. +Integer+ for +:int+). For multiple-argument parameters, the value can be any member of +MULTI_ARG_TYPES+ constant. If unset, the default argument type is +:flag+, meaning that the argument does not take a parameter. The specification of +:type+ is not necessary if a +:default+ is given.
95
+ ## [+:default+] Set the default value for an argument. Without a default value, the hash returned by #parse (and thus Trollop::options) will have a +nil+ value for this key unless the argument is given on the commandline. The argument type is derived automatically from the class of the default value given, so specifying a +:type+ is not necessary if a +:default+ is given. (But see below for an important caveat when +:multi+: is specified too.) If the argument is a flag, and the default is set to +true+, then if it is specified on the the commandline the value will be +false+.
96
+ ## [+:required+] If set to +true+, the argument must be provided on the commandline.
97
+ ## [+:multi+] If set to +true+, allows multiple occurrences of the option on the commandline. Otherwise, only a single instance of the option is allowed. (Note that this is different from taking multiple parameters. See below.)
98
+ ##
99
+ ## Note that there are two types of argument multiplicity: an argument
100
+ ## can take multiple values, e.g. "--arg 1 2 3". An argument can also
101
+ ## be allowed to occur multiple times, e.g. "--arg 1 --arg 2".
102
+ ##
103
+ ## Arguments that take multiple values should have a +:type+ parameter
104
+ ## drawn from +MULTI_ARG_TYPES+ (e.g. +:strings+), or a +:default:+
105
+ ## value of an array of the correct type (e.g. [String]). The
106
+ ## value of this argument will be an array of the parameters on the
107
+ ## commandline.
108
+ ##
109
+ ## Arguments that can occur multiple times should be marked with
110
+ ## +:multi+ => +true+. The value of this argument will also be an array.
111
+ ## In contrast with regular non-multi options, if not specified on
112
+ ## the commandline, the default value will be [], not nil.
113
+ ##
114
+ ## These two attributes can be combined (e.g. +:type+ => +:strings+,
115
+ ## +:multi+ => +true+), in which case the value of the argument will be
116
+ ## an array of arrays.
117
+ ##
118
+ ## There's one ambiguous case to be aware of: when +:multi+: is true and a
119
+ ## +:default+ is set to an array (of something), it's ambiguous whether this
120
+ ## is a multi-value argument as well as a multi-occurrence argument.
121
+ ## In thise case, Trollop assumes that it's not a multi-value argument.
122
+ ## If you want a multi-value, multi-occurrence argument with a default
123
+ ## value, you must specify +:type+ as well.
124
+
125
+ def opt name, desc="", opts={}
126
+ raise ArgumentError, "you already have an argument named '#{name}'" if @specs.member? name
127
+
128
+ ## fill in :type
129
+ opts[:type] = # normalize
130
+ case opts[:type]
131
+ when :boolean, :bool; :flag
132
+ when :integer; :int
133
+ when :integers; :ints
134
+ when :double; :float
135
+ when :doubles; :floats
136
+ when Class
137
+ case opts[:type].name
138
+ when 'TrueClass', 'FalseClass'; :flag
139
+ when 'String'; :string
140
+ when 'Integer'; :int
141
+ when 'Float'; :float
142
+ when 'IO'; :io
143
+ when 'Date'; :date
144
+ else
145
+ raise ArgumentError, "unsupported argument type '#{opts[:type].class.name}'"
146
+ end
147
+ when nil; nil
148
+ else
149
+ raise ArgumentError, "unsupported argument type '#{opts[:type]}'" unless TYPES.include?(opts[:type])
150
+ opts[:type]
151
+ end
152
+
153
+ ## for options with :multi => true, an array default doesn't imply
154
+ ## a multi-valued argument. for that you have to specify a :type
155
+ ## as well. (this is how we disambiguate an ambiguous situation;
156
+ ## see the docs for Parser#opt for details.)
157
+ disambiguated_default =
158
+ if opts[:multi] && opts[:default].is_a?(Array) && !opts[:type]
159
+ opts[:default].first
160
+ else
161
+ opts[:default]
162
+ end
163
+
164
+ type_from_default =
165
+ case disambiguated_default
166
+ when Integer; :int
167
+ when Numeric; :float
168
+ when TrueClass, FalseClass; :flag
169
+ when String; :string
170
+ when IO; :io
171
+ when Date; :date
172
+ when Array
173
+ if opts[:default].empty?
174
+ raise ArgumentError, "multiple argument type cannot be deduced from an empty array for '#{opts[:default][0].class.name}'"
175
+ end
176
+ case opts[:default][0] # the first element determines the types
177
+ when Integer; :ints
178
+ when Numeric; :floats
179
+ when String; :strings
180
+ when IO; :ios
181
+ when Date; :dates
182
+ else
183
+ raise ArgumentError, "unsupported multiple argument type '#{opts[:default][0].class.name}'"
184
+ end
185
+ when nil; nil
186
+ else
187
+ raise ArgumentError, "unsupported argument type '#{opts[:default].class.name}'"
188
+ end
189
+
190
+ raise ArgumentError, ":type specification and default type don't match (default type is #{type_from_default})" if opts[:type] && type_from_default && opts[:type] != type_from_default
191
+
192
+ opts[:type] = opts[:type] || type_from_default || :flag
193
+
194
+ ## fill in :long
195
+ opts[:long] = opts[:long] ? opts[:long].to_s : name.to_s.gsub("_", "-")
196
+ opts[:long] =
197
+ case opts[:long]
198
+ when /^--([^-].*)$/
199
+ $1
200
+ when /^[^-]/
201
+ opts[:long]
202
+ else
203
+ raise ArgumentError, "invalid long option name #{opts[:long].inspect}"
204
+ end
205
+ raise ArgumentError, "long option name #{opts[:long].inspect} is already taken; please specify a (different) :long" if @long[opts[:long]]
206
+
207
+ ## fill in :short
208
+ opts[:short] = opts[:short].to_s if opts[:short] unless opts[:short] == :none
209
+ opts[:short] = case opts[:short]
210
+ when /^-(.)$/; $1
211
+ when nil, :none, /^.$/; opts[:short]
212
+ else raise ArgumentError, "invalid short option name '#{opts[:short].inspect}'"
213
+ end
214
+
215
+ if opts[:short]
216
+ raise ArgumentError, "short option name #{opts[:short].inspect} is already taken; please specify a (different) :short" if @short[opts[:short]]
217
+ raise ArgumentError, "a short option name can't be a number or a dash" if opts[:short] =~ INVALID_SHORT_ARG_REGEX
218
+ end
219
+
220
+ ## fill in :default for flags
221
+ opts[:default] = false if opts[:type] == :flag && opts[:default].nil?
222
+
223
+ ## autobox :default for :multi (multi-occurrence) arguments
224
+ opts[:default] = [opts[:default]] if opts[:default] && opts[:multi] && !opts[:default].is_a?(Array)
225
+
226
+ ## fill in :multi
227
+ opts[:multi] ||= false
228
+
229
+ opts[:desc] ||= desc
230
+ @long[opts[:long]] = name
231
+ @short[opts[:short]] = name if opts[:short] && opts[:short] != :none
232
+ @specs[name] = opts
233
+ @order << [:opt, name]
234
+ end
235
+
236
+ ## Sets the version string. If set, the user can request the version
237
+ ## on the commandline. Should probably be of the form "<program name>
238
+ ## <version number>".
239
+ def version s=nil; @version = s if s; @version end
240
+
241
+ ## Adds text to the help display. Can be interspersed with calls to
242
+ ## #opt to build a multi-section help page.
243
+ def banner s; @order << [:text, s] end
244
+ alias :text :banner
245
+
246
+ ## Marks two (or more!) options as requiring each other. Only handles
247
+ ## undirected (i.e., mutual) dependencies. Directed dependencies are
248
+ ## better modeled with Trollop::die.
249
+ def depends *syms
250
+ syms.each { |sym| raise ArgumentError, "unknown option '#{sym}'" unless @specs[sym] }
251
+ @constraints << [:depends, syms]
252
+ end
253
+
254
+ ## Marks two (or more!) options as conflicting.
255
+ def conflicts *syms
256
+ syms.each { |sym| raise ArgumentError, "unknown option '#{sym}'" unless @specs[sym] }
257
+ @constraints << [:conflicts, syms]
258
+ end
259
+
260
+ ## Defines a set of words which cause parsing to terminate when
261
+ ## encountered, such that any options to the left of the word are
262
+ ## parsed as usual, and options to the right of the word are left
263
+ ## intact.
264
+ ##
265
+ ## A typical use case would be for subcommand support, where these
266
+ ## would be set to the list of subcommands. A subsequent Trollop
267
+ ## invocation would then be used to parse subcommand options, after
268
+ ## shifting the subcommand off of ARGV.
269
+ def stop_on *words
270
+ @stop_words = [*words].flatten
271
+ end
272
+
273
+ ## Similar to #stop_on, but stops on any unknown word when encountered
274
+ ## (unless it is a parameter for an argument). This is useful for
275
+ ## cases where you don't know the set of subcommands ahead of time,
276
+ ## i.e., without first parsing the global options.
277
+ def stop_on_unknown
278
+ @stop_on_unknown = true
279
+ end
280
+
281
+ ## Parses the commandline. Typically called by Trollop::options,
282
+ ## but you can call it directly if you need more control.
283
+ ##
284
+ ## throws CommandlineError, HelpNeeded, and VersionNeeded exceptions.
285
+ def parse cmdline=ARGV
286
+ vals = {}
287
+ required = {}
288
+
289
+ opt :version, "Print version and exit" if @version unless @specs[:version] || @long["version"]
290
+ opt :help, "Show this message" unless @specs[:help] || @long["help"]
291
+
292
+ @specs.each do |sym, opts|
293
+ required[sym] = true if opts[:required]
294
+ vals[sym] = opts[:default]
295
+ vals[sym] = [] if opts[:multi] && !opts[:default] # multi arguments default to [], not nil
296
+ end
297
+
298
+ resolve_default_short_options
299
+
300
+ ## resolve symbols
301
+ given_args = {}
302
+ @leftovers = each_arg cmdline do |arg, params|
303
+ sym = case arg
304
+ when /^-([^-])$/
305
+ @short[$1]
306
+ when /^--([^-]\S*)$/
307
+ @long[$1]
308
+ else
309
+ raise CommandlineError, "invalid argument syntax: '#{arg}'"
310
+ end
311
+ raise CommandlineError, "unknown argument '#{arg}'" unless sym
312
+
313
+ if given_args.include?(sym) && !@specs[sym][:multi]
314
+ raise CommandlineError, "option '#{arg}' specified multiple times"
315
+ end
316
+
317
+ given_args[sym] ||= {}
318
+
319
+ given_args[sym][:arg] = arg
320
+ given_args[sym][:params] ||= []
321
+
322
+ # The block returns the number of parameters taken.
323
+ num_params_taken = 0
324
+
325
+ unless params.nil?
326
+ if SINGLE_ARG_TYPES.include?(@specs[sym][:type])
327
+ given_args[sym][:params] << params[0, 1] # take the first parameter
328
+ num_params_taken = 1
329
+ elsif MULTI_ARG_TYPES.include?(@specs[sym][:type])
330
+ given_args[sym][:params] << params # take all the parameters
331
+ num_params_taken = params.size
332
+ end
333
+ end
334
+
335
+ num_params_taken
336
+ end
337
+
338
+ ## check for version and help args
339
+ raise VersionNeeded if given_args.include? :version
340
+ raise HelpNeeded if given_args.include? :help
341
+
342
+ ## check constraint satisfaction
343
+ @constraints.each do |type, syms|
344
+ constraint_sym = syms.find { |sym| given_args[sym] }
345
+ next unless constraint_sym
346
+
347
+ case type
348
+ when :depends
349
+ syms.each { |sym| raise CommandlineError, "--#{@specs[constraint_sym][:long]} requires --#{@specs[sym][:long]}" unless given_args.include? sym }
350
+ when :conflicts
351
+ syms.each { |sym| raise CommandlineError, "--#{@specs[constraint_sym][:long]} conflicts with --#{@specs[sym][:long]}" if given_args.include?(sym) && (sym != constraint_sym) }
352
+ end
353
+ end
354
+
355
+ required.each do |sym, val|
356
+ raise CommandlineError, "option --#{@specs[sym][:long]} must be specified" unless given_args.include? sym
357
+ end
358
+
359
+ ## parse parameters
360
+ given_args.each do |sym, given_data|
361
+ arg = given_data[:arg]
362
+ params = given_data[:params]
363
+
364
+ opts = @specs[sym]
365
+ raise CommandlineError, "option '#{arg}' needs a parameter" if params.empty? && opts[:type] != :flag and not opts[:allow_blank]
366
+
367
+ vals["#{sym}_given".intern] = true # mark argument as specified on the commandline
368
+
369
+ case opts[:type]
370
+ when :flag
371
+ vals[sym] = !opts[:default]
372
+ when :int, :ints
373
+ vals[sym] = params.map { |pg| pg.map { |p| parse_integer_parameter p, arg } }
374
+ when :float, :floats
375
+ vals[sym] = params.map { |pg| pg.map { |p| parse_float_parameter p, arg } }
376
+ when :string, :strings
377
+ vals[sym] = params.map { |pg| pg.map { |p| p.to_s } }
378
+ when :io, :ios
379
+ vals[sym] = params.map { |pg| pg.map { |p| parse_io_parameter p, arg } }
380
+ when :date, :dates
381
+ vals[sym] = params.map { |pg| pg.map { |p| parse_date_parameter p, arg } }
382
+ end
383
+
384
+ if SINGLE_ARG_TYPES.include?(opts[:type])
385
+ unless opts[:multi] # single parameter
386
+ vals[sym] = vals[sym][0][0] rescue nil
387
+ else # multiple options, each with a single parameter
388
+ vals[sym] = vals[sym].map { |p| p[0] }
389
+ end
390
+ elsif MULTI_ARG_TYPES.include?(opts[:type]) && !opts[:multi]
391
+ vals[sym] = vals[sym][0] # single option, with multiple parameters
392
+ end
393
+ # else: multiple options, with multiple parameters
394
+ end
395
+
396
+ ## modify input in place with only those
397
+ ## arguments we didn't process
398
+ cmdline.clear
399
+ @leftovers.each { |l| cmdline << l }
400
+
401
+ ## allow openstruct-style accessors
402
+ class << vals
403
+ def method_missing(m, *args)
404
+ self[m] || self[m.to_s]
405
+ end
406
+ end
407
+ vals
408
+ end
409
+
410
+ def parse_date_parameter param, arg #:nodoc:
411
+ begin
412
+ begin
413
+ time = Chronic.parse(param)
414
+ rescue NameError
415
+ # chronic is not available
416
+ end
417
+ time ? Date.new(time.year, time.month, time.day) : Date.parse(param)
418
+ rescue ArgumentError => e
419
+ raise CommandlineError, "option '#{arg}' needs a date"
420
+ end
421
+ end
422
+
423
+ ## Print the help message to +stream+.
424
+ def educate stream=$stdout
425
+ width # just calculate it now; otherwise we have to be careful not to
426
+ # call this unless the cursor's at the beginning of a line.
427
+
428
+ left = {}
429
+ @specs.each do |name, spec|
430
+ left[name] = "--#{spec[:long]}" +
431
+ (spec[:short] && spec[:short] != :none ? ", -#{spec[:short]}" : "") +
432
+ case spec[:type]
433
+ when :flag; ""
434
+ when :int; " <i>"
435
+ when :ints; " <i+>"
436
+ when :string; " <s>"
437
+ when :strings; " <s+>"
438
+ when :float; " <f>"
439
+ when :floats; " <f+>"
440
+ when :io; " <filename/uri>"
441
+ when :ios; " <filename/uri+>"
442
+ when :date; " <date>"
443
+ when :dates; " <date+>"
444
+ end
445
+ end
446
+
447
+ leftcol_width = left.values.map { |s| s.length }.max || 0
448
+ rightcol_start = leftcol_width + 6 # spaces
449
+
450
+ unless @order.size > 0 && @order.first.first == :text
451
+ stream.puts "#@version\n" if @version
452
+ stream.puts "Options:"
453
+ end
454
+
455
+ @order.each do |what, opt|
456
+ if what == :text
457
+ stream.puts wrap(opt)
458
+ next
459
+ end
460
+
461
+ spec = @specs[opt]
462
+ stream.printf " %#{leftcol_width}s: ", left[opt]
463
+ desc = spec[:desc] + begin
464
+ default_s = case spec[:default]
465
+ when $stdout; "<stdout>"
466
+ when $stdin; "<stdin>"
467
+ when $stderr; "<stderr>"
468
+ when Array
469
+ spec[:default].join(", ")
470
+ else
471
+ spec[:default].to_s
472
+ end
473
+
474
+ if spec[:default]
475
+ if spec[:desc] =~ /\.$/
476
+ " (Default: #{default_s})"
477
+ else
478
+ " (default: #{default_s})"
479
+ end
480
+ else
481
+ ""
482
+ end
483
+ end
484
+ stream.puts wrap(desc, :width => width - rightcol_start - 1, :prefix => rightcol_start)
485
+ end
486
+ end
487
+
488
+ def width #:nodoc:
489
+ @width ||= if $stdout.tty?
490
+ begin
491
+ require 'curses'
492
+ Curses::init_screen
493
+ x = Curses::cols
494
+ Curses::close_screen
495
+ x
496
+ rescue Exception
497
+ 80
498
+ end
499
+ else
500
+ 80
501
+ end
502
+ end
503
+
504
+ def wrap str, opts={} # :nodoc:
505
+ if str == ""
506
+ [""]
507
+ else
508
+ str.split("\n").map { |s| wrap_line s, opts }.flatten
509
+ end
510
+ end
511
+
512
+ ## The per-parser version of Trollop::die (see that for documentation).
513
+ def die arg, msg
514
+ if msg
515
+ $stderr.puts "Error: argument --#{@specs[arg][:long]} #{msg}."
516
+ else
517
+ $stderr.puts "Error: #{arg}."
518
+ end
519
+ $stderr.puts "Try --help for help."
520
+ exit(-1)
521
+ end
522
+
523
+ private
524
+
525
+ ## yield successive arg, parameter pairs
526
+ def each_arg args
527
+ remains = []
528
+ i = 0
529
+
530
+ until i >= args.length
531
+ if @stop_words.member? args[i]
532
+ remains += args[i .. -1]
533
+ return remains
534
+ end
535
+ case args[i]
536
+ when /^--$/ # arg terminator
537
+ remains += args[(i + 1) .. -1]
538
+ return remains
539
+ when /^--(\S+?)=(.*)$/ # long argument with equals
540
+ yield "--#{$1}", [$2]
541
+ i += 1
542
+ when /^--(\S+)$/ # long argument
543
+ params = collect_argument_parameters(args, i + 1)
544
+ unless params.empty?
545
+ num_params_taken = yield args[i], params
546
+ unless num_params_taken
547
+ if @stop_on_unknown
548
+ remains += args[i + 1 .. -1]
549
+ return remains
550
+ else
551
+ remains += params
552
+ end
553
+ end
554
+ i += 1 + num_params_taken
555
+ else # long argument no parameter
556
+ yield args[i], nil
557
+ i += 1
558
+ end
559
+ when /^-(\S+)$/ # one or more short arguments
560
+ shortargs = $1.split(//)
561
+ shortargs.each_with_index do |a, j|
562
+ if j == (shortargs.length - 1)
563
+ params = collect_argument_parameters(args, i + 1)
564
+ unless params.empty?
565
+ num_params_taken = yield "-#{a}", params
566
+ unless num_params_taken
567
+ if @stop_on_unknown
568
+ remains += args[i + 1 .. -1]
569
+ return remains
570
+ else
571
+ remains += params
572
+ end
573
+ end
574
+ i += 1 + num_params_taken
575
+ else # argument no parameter
576
+ yield "-#{a}", nil
577
+ i += 1
578
+ end
579
+ else
580
+ yield "-#{a}", nil
581
+ end
582
+ end
583
+ else
584
+ if @stop_on_unknown
585
+ remains += args[i .. -1]
586
+ return remains
587
+ else
588
+ remains << args[i]
589
+ i += 1
590
+ end
591
+ end
592
+ end
593
+
594
+ remains
595
+ end
596
+
597
+ def parse_integer_parameter param, arg
598
+ raise CommandlineError, "option '#{arg}' needs an integer" unless param =~ /^\d+$/
599
+ param.to_i
600
+ end
601
+
602
+ def parse_float_parameter param, arg
603
+ raise CommandlineError, "option '#{arg}' needs a floating-point number" unless param =~ FLOAT_RE
604
+ param.to_f
605
+ end
606
+
607
+ def parse_io_parameter param, arg
608
+ case param
609
+ when /^(stdin|-)$/i; $stdin
610
+ else
611
+ require 'open-uri'
612
+ begin
613
+ open param
614
+ rescue SystemCallError => e
615
+ raise CommandlineError, "file or url for option '#{arg}' cannot be opened: #{e.message}"
616
+ end
617
+ end
618
+ end
619
+
620
+ def collect_argument_parameters args, start_at
621
+ params = []
622
+ pos = start_at
623
+ while args[pos] && args[pos] !~ PARAM_RE && !@stop_words.member?(args[pos]) do
624
+ params << args[pos]
625
+ pos += 1
626
+ end
627
+ params
628
+ end
629
+
630
+ def resolve_default_short_options
631
+ @order.each do |type, name|
632
+ next unless type == :opt
633
+ opts = @specs[name]
634
+ next if opts[:short]
635
+
636
+ c = opts[:long].split(//).find { |d| d !~ INVALID_SHORT_ARG_REGEX && !@short.member?(d) }
637
+ if c # found a character to use
638
+ opts[:short] = c
639
+ @short[c] = name
640
+ end
641
+ end
642
+ end
643
+
644
+ def wrap_line str, opts={}
645
+ prefix = opts[:prefix] || 0
646
+ width = opts[:width] || (self.width - 1)
647
+ start = 0
648
+ ret = []
649
+ until start > str.length
650
+ nextt =
651
+ if start + width >= str.length
652
+ str.length
653
+ else
654
+ x = str.rindex(/\s/, start + width)
655
+ x = str.index(/\s/, start) if x && x < start
656
+ x || str.length
657
+ end
658
+ ret << (ret.empty? ? "" : " " * prefix) + str[start ... nextt]
659
+ start = nextt + 1
660
+ end
661
+ ret
662
+ end
663
+
664
+ ## instance_eval but with ability to handle block arguments
665
+ ## thanks to why: http://redhanded.hobix.com/inspect/aBlockCostume.html
666
+ def cloaker &b
667
+ (class << self; self; end).class_eval do
668
+ define_method :cloaker_, &b
669
+ meth = instance_method :cloaker_
670
+ remove_method :cloaker_
671
+ meth
672
+ end
673
+ end
674
+ end
675
+
676
+ ## The easy, syntactic-sugary entry method into Trollop. Creates a Parser,
677
+ ## passes the block to it, then parses +args+ with it, handling any errors or
678
+ ## requests for help or version information appropriately (and then exiting).
679
+ ## Modifies +args+ in place. Returns a hash of option values.
680
+ ##
681
+ ## The block passed in should contain zero or more calls to +opt+
682
+ ## (Parser#opt), zero or more calls to +text+ (Parser#text), and
683
+ ## probably a call to +version+ (Parser#version).
684
+ ##
685
+ ## The returned block contains a value for every option specified with
686
+ ## +opt+. The value will be the value given on the commandline, or the
687
+ ## default value if the option was not specified on the commandline. For
688
+ ## every option specified on the commandline, a key "<option
689
+ ## name>_given" will also be set in the hash.
690
+ ##
691
+ ## Example:
692
+ ##
693
+ ## require 'trollop'
694
+ ## opts = Trollop::options do
695
+ ## opt :monkey, "Use monkey mode" # a flag --monkey, defaulting to false
696
+ ## opt :goat, "Use goat mode", :default => true # a flag --goat, defaulting to true
697
+ ## opt :num_limbs, "Number of limbs", :default => 4 # an integer --num-limbs <i>, defaulting to 4
698
+ ## opt :num_thumbs, "Number of thumbs", :type => :int # an integer --num-thumbs <i>, defaulting to nil
699
+ ## end
700
+ ##
701
+ ## ## if called with no arguments
702
+ ## p opts # => { :monkey => false, :goat => true, :num_limbs => 4, :num_thumbs => nil }
703
+ ##
704
+ ## ## if called with --monkey
705
+ ## p opts # => {:monkey_given=>true, :monkey=>true, :goat=>true, :num_limbs=>4, :help=>false, :num_thumbs=>nil}
706
+ ##
707
+ ## See more examples at http://trollop.rubyforge.org.
708
+ def options args=ARGV, *a, &b
709
+ @last_parser = Parser.new(*a, &b)
710
+ with_standard_exception_handling(@last_parser) { @last_parser.parse args }
711
+ end
712
+
713
+ ## If Trollop::options doesn't do quite what you want, you can create a Parser
714
+ ## object and call Parser#parse on it. That method will throw CommandlineError,
715
+ ## HelpNeeded and VersionNeeded exceptions when necessary; if you want to
716
+ ## have these handled for you in the standard manner (e.g. show the help
717
+ ## and then exit upon an HelpNeeded exception), call your code from within
718
+ ## a block passed to this method.
719
+ ##
720
+ ## Note that this method will call System#exit after handling an exception!
721
+ ##
722
+ ## Usage example:
723
+ ##
724
+ ## require 'trollop'
725
+ ## p = Trollop::Parser.new do
726
+ ## opt :monkey, "Use monkey mode" # a flag --monkey, defaulting to false
727
+ ## opt :goat, "Use goat mode", :default => true # a flag --goat, defaulting to true
728
+ ## end
729
+ ##
730
+ ## opts = Trollop::with_standard_exception_handling p do
731
+ ## o = p.parse ARGV
732
+ ## raise Trollop::HelpNeeded if ARGV.empty? # show help screen
733
+ ## o
734
+ ## end
735
+ ##
736
+ ## Requires passing in the parser object.
737
+
738
+ def with_standard_exception_handling parser
739
+ begin
740
+ yield
741
+ rescue CommandlineError => e
742
+ $stderr.puts "Error: #{e.message}."
743
+ $stderr.puts "Try --help for help."
744
+ exit(-1)
745
+ rescue HelpNeeded
746
+ parser.educate
747
+ exit
748
+ rescue VersionNeeded
749
+ puts parser.version
750
+ exit
751
+ end
752
+ end
753
+
754
+ ## Informs the user that their usage of 'arg' was wrong, as detailed by
755
+ ## 'msg', and dies. Example:
756
+ ##
757
+ ## options do
758
+ ## opt :volume, :default => 0.0
759
+ ## end
760
+ ##
761
+ ## die :volume, "too loud" if opts[:volume] > 10.0
762
+ ## die :volume, "too soft" if opts[:volume] < 0.1
763
+ ##
764
+ ## In the one-argument case, simply print that message, a notice
765
+ ## about -h, and die. Example:
766
+ ##
767
+ ## options do
768
+ ## opt :whatever # ...
769
+ ## end
770
+ ##
771
+ ## Trollop::die "need at least one filename" if ARGV.empty?
772
+ def die arg, msg=nil
773
+ if @last_parser
774
+ @last_parser.die arg, msg
775
+ else
776
+ raise ArgumentError, "Trollop::die can only be called after Trollop::options"
777
+ end
778
+ end
779
+
780
+ module_function :options, :die, :with_standard_exception_handling
781
+
782
+ end # module
@@ -25,5 +25,6 @@ Gem::Specification.new do |spec|
25
25
  spec.add_development_dependency "rake", "~> 10.2"
26
26
  spec.add_development_dependency "pry", "~> 0.9", ">= 0.9.12"
27
27
 
28
- spec.add_runtime_dependency "colorize", "~> 0.0"
28
+ spec.add_runtime_dependency "colorize", "~> 0.0"
29
+ spec.add_runtime_dependency "activesupport", "~> 4.0", ">= 4.0.2"
29
30
  end
metadata CHANGED
@@ -1,7 +1,7 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: scaffold_sinatra
3
3
  version: !ruby/object:Gem::Version
4
- version: 0.0.4
4
+ version: 0.0.5
5
5
  platform: ruby
6
6
  authors:
7
7
  - h4w5
@@ -9,7 +9,7 @@ authors:
9
9
  autorequire:
10
10
  bindir: bin
11
11
  cert_chain: []
12
- date: 2014-09-10 00:00:00.000000000 Z
12
+ date: 2014-09-15 00:00:00.000000000 Z
13
13
  dependencies:
14
14
  - !ruby/object:Gem::Dependency
15
15
  name: bundler
@@ -73,6 +73,26 @@ dependencies:
73
73
  - - "~>"
74
74
  - !ruby/object:Gem::Version
75
75
  version: '0.0'
76
+ - !ruby/object:Gem::Dependency
77
+ name: activesupport
78
+ requirement: !ruby/object:Gem::Requirement
79
+ requirements:
80
+ - - "~>"
81
+ - !ruby/object:Gem::Version
82
+ version: '4.0'
83
+ - - ">="
84
+ - !ruby/object:Gem::Version
85
+ version: 4.0.2
86
+ type: :runtime
87
+ prerelease: false
88
+ version_requirements: !ruby/object:Gem::Requirement
89
+ requirements:
90
+ - - "~>"
91
+ - !ruby/object:Gem::Version
92
+ version: '4.0'
93
+ - - ">="
94
+ - !ruby/object:Gem::Version
95
+ version: 4.0.2
76
96
  description: Helps scaffold a simple Sinatra app according to the WDI conventions...
77
97
  email:
78
98
  - philip@h4w5.com
@@ -86,17 +106,27 @@ files:
86
106
  - LICENSE.txt
87
107
  - README.md
88
108
  - Rakefile
109
+ - app.rb
89
110
  - bin/scaffold_sinatra
111
+ - config.ru
112
+ - data/.env
113
+ - data/.gitignore
90
114
  - data/Gemfile.erb
91
115
  - data/Rakefile
92
116
  - data/app.rb.erb
117
+ - data/boot.rb
93
118
  - data/config.ru.erb
94
119
  - data/public/images/GA-logo-small.png
120
+ - data/public/images/ga-favicon.ico
95
121
  - data/public/stylesheets/style.css.erb
122
+ - data/readme.md.erb
96
123
  - data/views/index.erb.erb
97
124
  - data/views/layout.erb.erb
98
125
  - lib/scaffold_sinatra.rb
126
+ - lib/scaffold_sinatra/scaffolds.rb
127
+ - lib/scaffold_sinatra/utils.rb
99
128
  - lib/scaffold_sinatra/version.rb
129
+ - lib/trollop.rb
100
130
  - scaffold_sinatra.gemspec
101
131
  homepage: https://github.com/ga-instructors
102
132
  licenses: