camping 2.1.532 → 3.0.0

data/lib/camping/commands.rb

@@ -0,0 +1,388 @@
+module Camping
+  module CommandsHelpers
+
+    # transform app_name to snake case
+    def self.to_snake_case(string)
+      string = string.to_s if string.class == Symbol
+      string.gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+    end
+
+    RouteCollection = Struct.new(:routes)
+    class RouteCollection
+      # Displays formatted routes from a route collection
+      # Assumes that Route structs are stored in :routes.
+      def display
+        current_app, current_controller, current_method = "", "", ""
+        puts "App      VERB     Route"
+        routes.each { |r|
+          if current_app != r.app.to_s
+            current_app = r.app.to_s
+            puts "-----------------------------------"
+            puts r.app_header
+          end
+          if current_controller != r.controller.to_s
+            current_controller = r.controller.to_s
+            puts r.controller_header
+          end
+          puts r.padded_message true
+        }
+      end
+
+    end
+
+    # Route Struct, for making and formatting a route.
+    Route = Struct.new(:http_method, :controller, :app, :url)
+    class Route
+
+      def to_s
+        "#{controller}: #{http_method}: #{url} - #{replace_reg url}"
+      end
+
+      # pad the controller name to be the right length, if we can.
+      def padded_message(with_method = false)
+        "#{pad}#{(with_method ? http_method.to_s.upcase.ljust(pad.length, " ") : pad)}#{replace_reg url}"
+      end
+
+      def app_header
+        "#{app.to_s}"
+      end
+
+      def controller_header
+        "#{pad}#{app.to_s}::#{controller.to_s}"
+      end
+
+      protected
+
+      def http_methods
+        ["get", "post", "put", "patch", "delete"]
+      end
+
+      def replace_reg(pattern = "")
+        xstr = "([^/]+)"; nstr = "(\d+)"
+        pattern = pattern.gsub(xstr, ":string").gsub("(\\d+)", ":integer") unless pattern == "/"
+        pattern
+      end
+
+      def pad
+        "         "
+      end
+
+    end
+
+    class RoutesParser
+      def self.parse(app)
+        new(app).parse
+      end
+
+      def initialize(app = Camping)
+        @parent_app, @routes = app, []
+      end
+
+      def parse
+        routes = @parent_app.make_camp
+        collected_routes = []
+
+        make_routes = -> (a) {
+
+          a::X.all.map {|c|
+            k = a::X.const_get(c)
+            im = k.instance_methods(false).map!(&:to_s)
+            methods = im & ["get", "post", "put", "patch", "delete"]
+            if k.respond_to?:urls
+              methods.each { |m|
+                k.urls.each { |u|
+                  collected_routes.append Camping::CommandsHelpers::Route.new(m,c,a.to_s,u)
+                }
+              }
+            end
+          }
+        }
+
+        if @parent_app == Camping
+          @parent_app::Apps.each {|a|
+            make_routes.(a)
+          }
+        else
+          make_routes.(@parent_app)
+        end
+
+        routes_collection = Camping::CommandsHelpers::RouteCollection.new(collected_routes)
+      end
+    end
+
+  end
+
+  class Generators
+    class << self
+
+      # write a file
+      def write(file, content)
+        raise "Cannot write to nil file." unless file
+        folder = File.dirname(file)
+        `mkdir -p #{folder}` unless File.exist?(folder)
+        File.open(file, 'w') { |f| f.write content }
+      end
+
+      # read a file
+      def read(file)
+        File.read(file)
+      end
+
+      def make_camp_file(app_name="Tent")
+        write "camp.rb", <<-RUBY
+require 'camping'
+
+Camping.goes :#{app_name}
+
+module #{app_name}
+  module Models
+  end
+
+  module Controllers
+    class Index
+      def get
+        @title = "#{app_name}"
+        render :index
+      end
+    end
+  end
+
+  module Helpers
+  end
+
+  module Views
+
+    def layout
+      html do
+        head do
+          title '#{app_name}'
+          link :rel => 'stylesheet', :type => 'text/css',
+          :href => '/styles.css', :media => 'screen'
+        end
+        body do
+          h1 '#{app_name}'
+
+          div.wrapper! do
+            self << yield
+          end
+        end
+      end
+    end
+
+    def index
+      h2 'Let\'s go Camping'
+    end
+
+  end
+
+end
+
+RUBY
+      end
+
+      # makes a gitignore.
+      def make_gitignore
+        write '.gitignore', <<-GIT
+.DS_Store
+node_modules/
+tmp/
+db/camping.db
+db/camping.sqlite3
+db/camping.sqlite
+GIT
+      end
+
+      def make_ruby_version
+        write '.ruby-version', <<-RUBY
+#{RUBY_VERSION}
+RUBY
+      end
+
+      # writes a rakefile
+      def make_rakefile
+        write 'Rakefile', <<-TXT
+# Rakefile
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'tempfile'
+require 'open3'
+
+task :default => :test
+task :test => 'test:all'
+
+namespace 'test' do
+  Rake::TestTask.new('all') do |t|
+    t.libs << 'test'
+    t.test_files = FileList['test/nuts_*.rb']
+  end
+end
+TXT
+      end
+
+      # write a config.kdl
+      def make_configkdl
+        write 'config.kdl', <<-KDL
+# config.kdl
+hostname {
+  default "localhost"
+}
+KDL
+      end
+
+      # write a Gemfile
+      def make_gemfile
+        write 'Gemfile', <<-GEM
+# frozen_string_literal: true
+source 'https://rubygems.org'
+
+gem 'camping'
+gem 'puma'
+gem 'rake'
+
+group :production do
+  gem 'rack-ssl-enforcer'
+end
+
+group :development do
+end
+
+group :test do
+  gem 'minitest', '~> 5.0'
+  gem 'minitest-reporters'
+  gem 'rack-test'
+end
+
+GEM
+      end
+
+      # write a README.md
+      def make_readme
+        write 'README.md', <<-READ
+# Camping
+Camping is really fun and I hope you enjoy it.
+
+Start camping by running: `camping` in the root directory.
+
+READ
+      end
+
+      def make_public_folder
+        Dir.mkdir("public") unless Dir.exist?("public")
+      end
+
+      def make_test_folder
+        Dir.mkdir("test") unless Dir.exist?("test")
+        write 'test/test_helper.rb', <<-RUBY
+$:.unshift File.dirname(__FILE__) + '/../'
+# shift to act like we're in the regular degular directory
+
+begin
+  require 'rubygems'
+rescue LoadError
+end
+
+require 'camping'
+require 'minitest/autorun'
+require 'minitest'
+require 'rack/test'
+require "minitest/reporters"
+Minitest::Reporters.use! [Minitest::Reporters::DefaultReporter.new(:color => true)]
+
+class TestCase < MiniTest::Test
+  include Rack::Test::Methods
+
+  def self.inherited(mod)
+    mod.app = Object.const_get(mod.to_s[/\w+/])
+    super
+  end
+
+  class << self
+    attr_accessor :app
+  end
+
+  def body() last_response.body end
+  def app()  self.class.app     end
+
+  def assert_reverse
+    begin
+      yield
+    rescue Exception
+    else
+      assert false, "Block didn't fail"
+    end
+  end
+
+  def assert_body(str)
+    case str
+    when Regexp
+      assert_match(str, last_response.body.strip)
+    else
+      assert_equal(str.to_s, last_response.body.strip)
+    end
+  end
+
+  def assert_status(code)
+    assert_equal(code, last_response.status)
+  end
+
+  def test_silly; end
+
+end
+
+RUBY
+      end
+
+    end
+  end
+
+  class Commands
+
+    # A helper method to spit out Routes for an application
+    def self.routes(theApp = Camping, silent = false)
+      routes = Camping::CommandsHelpers::RoutesParser.parse theApp
+      routes.display unless silent == true
+      return routes
+    end
+
+    def self.new_cmd(app_name=:Camp)
+      app_name = :Camp if app_name == nil
+      app_name = app_name.to_sym if app_name.class == String
+
+      snake_app_name = Camping::CommandsHelpers.to_snake_case(app_name)
+
+      # make a directory then move there.
+      # _original_dir = Dir.pwd
+      Dir.mkdir("#{snake_app_name}") unless Dir.exist?("#{snake_app_name}")
+      Dir.chdir("#{snake_app_name}")
+
+      # generate a new camping app in a directory named after it:
+      Generators::make_camp_file(app_name)
+      Generators::make_gitignore()
+      Generators::make_rakefile()
+      Generators::make_ruby_version()
+      Generators::make_configkdl()
+      Generators::make_gemfile()
+      Generators::make_readme()
+      Generators::make_public_folder()
+      Generators::make_test_folder()
+
+      # optionally add omnibus support
+        # add src/ folder
+        # add lib/ folder
+        # add views/ folder
+
+      # optionally add a local database too, through guidebook
+        # add db/ folder
+        # add db/migrate folder
+        # add db/config.kdl
+        # append migrations stuff to Rakefile.
+        `ls`
+    end
+
+  end
+end

data/lib/camping/gear/filters.rb

@@ -0,0 +1,48 @@
+# This gear is originally from filtering_camping gem by judofyr, and techarc.
+module Gear
+	module Filters
+		module ClassMethods
+			def filters
+				@_filters ||= {:before => [], :after => []}
+			end
+
+			def before(actions, &blk)
+				actions = [actions] unless actions.is_a?(Array)
+				actions.each do |action|
+					filters[:before] << [action, blk]
+				end
+			end
+
+			def after(actions, &blk)
+				actions = [actions] unless actions.is_a?(Array)
+				actions.each do |action|
+					filters[:after] << [action, blk]
+				end
+			end
+		end
+
+		def self.included(mod)
+			mod.extend(ClassMethods)
+		end
+
+		def self.setup(app, *a, &block) end
+
+		def run_filters(type)
+			o = self.class.to_s.split("::")
+			filters = Object.const_get(o.first).filters
+			filters[type].each do |filter|
+				if (filter[0].is_a?(Symbol) && (filter[0] == o.last.to_sym || filter[0] == :all)) ||
+				 	(filter[0].is_a?(String) && /^#{filter[0]}\/?$/ =~ @env.REQUEST_URI)
+				 	self.instance_eval(&filter[1])
+				end
+			end
+		end
+
+		def service(*a)
+			run_filters(:before)
+			super(*a)
+			run_filters(:after)
+			self
+		end
+	end
+end

data/lib/camping/gear/inspection.rb

@@ -0,0 +1,32 @@
+
+# This gear adds inspection utilities to Camping
+module Gear
+  module Inspection
+
+    # reserved module for Camping Class Methods we add because we're the best.
+    module ClassMethods
+
+    end
+
+    module ControllersClassMethods
+      # All Helper helps us inspect our Controllers from outside of the app.
+      # TODO: Move to CampTools for introspection.
+      def all
+        all = []
+        constants.map { |c|
+          all << c.name if !["I", "Camper"].include? c.to_s
+        }
+        all
+      end
+    end
+
+    def self.included(mod)
+      mod.extend(ClassMethods)
+      mod::Controllers.extend(ControllersClassMethods)
+    end
+
+    # empty setup as determined by the Camping Gear Spec API.
+    def self.setup(app, *a, &block) end
+
+  end
+end

data/lib/camping/gear/kuddly.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+# lib/camping/config
+# load and parse settings.
+
+begin
+  require 'kdl'
+rescue LoadError => e
+  raise "kdl could not be loaded (is it installed?): #{e.message}"
+end
+
+module Gear
+
+  # Namespace to hide all of the KDL Configure stuff.
+  module Kuddly
+    WARNINGS = []
+
+    module ClassMethods
+      def configure(app)
+        config = Gear::Kuddly.get_config()
+        config.each do |k,v|
+          app.set(k.to_sym, v)
+        end unless config == nil
+      end
+    end
+
+    class << self
+
+      def included(mod)
+        mod.extend(ClassMethods)
+      end
+
+      # required for compliance reasons
+      def setup(app, *a, &block) end
+
+      def kdl_error_message(kdl_string="",error_message="", error=nil)
+        # parse error message to get line number and column:
+        m = error_message.match( /\((\d)+:(\d)\)/ )
+
+        if m == nil
+          warn "kdl_error_message was called on a nil error message?"
+          warn "message: #{error_message}"
+          warn "kdl_string: #{kdl_string}"
+          warn "current dir: #{Dir.pwd}"
+          warn "#{error}"
+          return
+        end
+
+        line = m[1].to_i
+        lines = kdl_string.split( "\n" )
+
+        em = "\n"
+        em << "#{line-4}: #{lines[line-4]}\n" if (line-4) > 0 && (line-4) < lines.count
+        em << "#{line-3}: #{lines[line-3]}\n" if (line-3) > 0 && (line-3) < lines.count
+        em << "#{line-2}: #{lines[line-2]}\n" if (line-2) > 0 && (line-2) < lines.count
+        em << "#{line-1}: #{lines[line-1]}\n" if (line-1) > 0 && (line-1) < lines.count
+        em << "#{line}: #{lines[line]}\n"     if   (line)
+        em << "#{line+1}: #{lines[line+1]}\n" if (line+1) > 0 && (line+1) < lines.count
+        em << "#{line+2}: #{lines[line+2]}\n" if (line+2) > 0 && (line+2) < lines.count
+        em << "#{line+3}: #{lines[line+3]}\n" if (line+3) > 0 && (line+3) < lines.count
+        em << "#{line+4}: #{lines[line+4]}\n" if (line+4) > 0 && (line+4) < lines.count
+        # em << "\n"
+        WARNINGS << em
+      end
+
+
+      # parses a kdl file into a kdl document Object.
+      # returns nil if it's false. Also assumes that the file is exists.
+      # an optional silence_warnings parameter is set to false. This is used for
+      # testing.
+      def parse_kdl(config_file = nil, silence_warnings = false)
+        begin
+          kdl_string = File.open(config_file).read
+        rescue => error # Errno::ENOENT
+          puts ""
+          puts "Error trying to read a config file: \"#{error}.\""
+          puts "  Attempted to open: #{config_file}"
+          puts "  Current directory: #{Dir.pwd}"
+          puts "  files in directory: #{Dir.glob('*')}"
+          puts ""
+        end
+
+        begin
+          kdl_doc = KDL.parse_document(kdl_string)
+        rescue => error
+          warn "#{error}"
+          # parse error message to get line number and column:
+          message = Kuddly.kdl_error_message(kdl_string, error.message, error)
+          m = error.message.match( /\((\d)+:(\d)\)/ )
+
+          line, column = m[1].to_i, m[2].to_i if m.respond_to? '[]'
+
+          warn("\nError parsing config: #{config_file}, on line: #{line}, at column: #{column}.", message, "#{error.message}", uplevel: 1) unless silence_warnings
+        end
+
+        kdl_doc
+      end
+
+      # Maps kdl settings. Settings Example:
+      # ```
+      # database {
+      #	  default adapter="sqlite3" database="#{database}" host="localhost" max_connections=5 timeout=5000
+      #	  development
+      #   test
+      #	  production adapter="postgres" database="kow"
+      # }
+      # ```
+      def map_kdl(kdl_doc=nil)
+        configs = {}
+
+        if kdl_doc
+
+          # We have a kdl document, so that's good.
+          # iterate through each top level node to see what kind of data we have.
+          kdl_doc.nodes.each do |d|
+            config_name = d.name.to_sym
+            configs[config_name] = {}
+
+            if d.children.length > 0
+              # we've got kids!
+              # This node will have sub nodes with properties
+              d.children.each do |en|
+                env_name = en.name.to_sym
+                # parse the settings for each environment
+                configs[config_name][env_name] = {}
+                en.properties.each do |key, value|
+                  configs[config_name][env_name][key.to_sym] = value.value
+                end
+              end
+            else
+              # we've got raw data, so place it into a default hash spot.
+              vals = []
+              if d.arguments.length > 1
+                d.arguments.each { |v| vals << v.value }
+              else
+                vals = d.arguments.first.value
+              end
+
+              configs[config_name]['default'] = vals
+            end
+          end
+        end
+
+        configs
+      end
+
+      # get_config
+      # searches for any kdl document inside of the root folder
+      # Then parses it, and merges the data based on the current environment.
+      def get_config(provided_config_file = nil)
+
+        config_file, kdl_doc, merged_configs = provided_config_file, nil, {}
+        config_file = get_root_config_file() unless provided_config_file != nil
+
+        # If the config file is just nil then we probably don't have one.
+        return nil unless config_file != nil
+
+        # parses then maps the kdl
+        configs = map_kdl(parse_kdl(config_file))
+        env = ENV['environment'] ||= "development"
+
+        configs.each do |key, setting|
+          if setting.has_key? :default && env.to_sym
+            merged_configs[key] = setting[:default].merge(setting[env.to_sym])
+          else
+            merged_configs[key] = setting['default']
+          end
+        end
+
+        merged_configs
+      end
+
+      # get kdl config file
+      def get_root_config_file(search_pattern = "config.kdl")
+        Dir.glob(search_pattern).first
+      end
+    end
+  end
+end