eucalypt 0.1.0

data/lib/eucalypt/eucalypt-security/namespaces/security-warden/templates/user.tt

@@ -0,0 +1,16 @@
+require 'eucalypt/eucalypt-security/namespaces/security-warden/user_confirm'
+class User < ActiveRecord::Base
+  validates :username, presence: true, uniqueness: true
+  validates :encrypted_password, presence: true
+
+  include BCrypt
+
+  def authenticate(attempt)
+    Password.new(self.encrypted_password) == attempt
+  end
+
+  def password=(entered_password)
+    @password = Password.create(entered_password)
+    self.encrypted_password = @password
+  end
+end

data/lib/eucalypt/eucalypt-security/namespaces/security-warden/templates/warden.tt

@@ -0,0 +1,35 @@
+class ApplicationController < Sinatra::Base
+  # Configure Warden for authentication
+  enable :sessions
+
+  use Warden::Manager do |config|
+    config.serialize_into_session{|user| user.id}
+    config.serialize_from_session{|id| User.find(id)}
+    config.scope_defaults :default, strategies: [:password], action: 'auth/invalid'
+    config.failure_app = self
+  end
+
+  Warden::Manager.before_failure {|env,opts| env['REQUEST_METHOD'] = 'POST'}
+  Warden::Strategies.add(:password) do
+    def valid?
+      params['user'] && params['user']['username'] && params['user']['password']
+    end
+    def authenticate!
+      unless (user = User.find_by_username params['user']['username'])
+        fail! 'The username you entered does not exist'
+      else
+        user.authenticate(params['user']['password']) ? success!(user) : fail!('Could not log in')
+      end
+    end
+  end
+
+  helpers do
+    def current_user
+      env['warden'].user
+    end
+
+    def authenticate
+      env['warden'].authenticate!
+    end
+  end
+end

data/lib/eucalypt/eucalypt-security/namespaces/security-warden/user_confirm.rb

@@ -0,0 +1,38 @@
+class User < ActiveRecord::Base
+  def with_confirm(*fields)
+    return if fields.empty?
+    fields.map(&:to_sym).each {|field| instance_variable_set "@with_confirm_#{field}", true }
+    class_eval do
+      attr_accessor *fields.map {|field| "#{field}_confirmation".to_sym }
+      attr_reader *fields.map {|field| field.to_sym }.reject {|field| field != :password}
+    end
+
+    fields.each do |field|
+      confirm = "confirm_#{field}".to_sym
+      define_singleton_method confirm do
+        if instance_variable_get "@with_#{confirm}"
+          case field
+          when :password
+            return if @password.nil?
+            unless authenticate @password_confirmation
+              errors.add :password_confirmation, "Passwords don't match"
+            end
+          else
+            actual = self.send field
+            return if actual.nil?
+            confirmation = instance_variable_get "@#{field}_confirmation"
+            unless actual == confirmation
+              errors.add "#{field}_confirmation", "#{field.to_s.pluralize.capitalize} don't match"
+            end
+          end
+        end
+      end
+
+      class_eval do
+        private confirm
+        validate confirm
+      end
+    end
+    self
+  end
+end

data/lib/eucalypt/helpers/colorize.rb

@@ -0,0 +1,27 @@
+module Eucalypt
+  module Helpers
+    module Colorize
+      ANSI = {
+        bold: '1',
+        red: '91',
+        yellow: '93',
+        blue: '94',
+        magenta: '95',
+        pale_blue: '34',
+        underline: '4',
+        grey: '90'
+      }
+
+      refine String do
+        def colorize(*opts)
+          "\e[#{opts.map{|o| ANSI[o]}*?;}m#{self}\e[0m"
+        end
+
+        def uncolorize
+          result = self.gsub /\e(\[|\])[0-9]+[0-9;]*m/, ''
+          result.nil? ? self : result
+        end
+      end
+    end
+  end
+end

data/lib/eucalypt/helpers/gemfile.rb

@@ -0,0 +1,48 @@
+require 'thor'
+require 'eucalypt/errors'
+
+module Eucalypt
+  module Helpers
+    module Gemfile
+      def gemfile_add(description, gems, directory)
+        gemfile = File.join(directory, 'Gemfile')
+        File.open gemfile do |f|
+          includes_gems = []
+          contents = f.read
+          gems.each do |gem, _|
+            includes_gems << true if contents.include? "gem '#{gem}'"
+          end
+          return unless includes_gems.empty?
+        end
+
+        append_to_file gemfile, "\n# #{description}\n"
+        gems.each_with_index do |gemdata, i|
+          gem, version = gemdata
+          gem_string = "gem '#{gem}', '#{version}'" << (i==gems.size-1 ? '' : "\n")
+          append_to_file gemfile, gem_string
+        end
+      end
+
+      class << self
+        def include?(gems, directory)
+          includes_gems = []
+          gemfile = File.join(directory, 'Gemfile')
+          File.open gemfile do |f|
+            contents = f.read
+            gems.each {|gem| includes_gems << contents.include?("gem '#{gem}'") }
+          end
+          includes_gems.all? {|present| present == true}
+        end
+
+        def check(gems, command, directory)
+          if include?(gems, directory)
+            true
+          else
+            Eucalypt::Error.no_gems(gems, command)
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eucalypt/helpers/inflect.rb

@@ -0,0 +1,79 @@
+require 'active_support'
+require 'active_support/core_ext'
+
+module Eucalypt
+  module Helpers
+    class Inflect
+      class << self
+        def route(string)
+          string.
+          underscore.
+          parameterize(separator: ?-).
+          gsub(?_,?-).
+          sub(/(^\-+?)(?=[A-Za-z0-9])/,'').
+          reverse.
+          sub(/(^\-+?)(?=[A-Za-z0-9])/,'').
+          reverse.
+          gsub(/\-\-+/,?-)
+        end
+
+        def resource(string)
+          route(string).gsub(?-,?_).singularize
+        end
+
+        def resources(string)
+          route(string).gsub(?-,?_).pluralize
+        end
+
+        def resource_keep_inflection(string)
+          route(string).gsub(?-,?_)
+        end
+
+        def constant(string)
+          resource(string).camelize
+        end
+
+        def constant_pluralize(string)
+          resources(string).camelize
+        end
+
+        %i[controller helper policy].each do |type|
+          define_method type do |string|
+            s = resource(string.singularize)
+            if s.end_with? "_#{type}"
+              name = s.split("_#{type}").first
+              "#{name.singularize}_#{type}"
+            else
+              "#{s.singularize}_#{type}"
+            end
+          end
+        end
+
+        def model(string)
+          resource(string.singularize)
+        end
+      end
+
+      attr_reader :name,
+                  :file_name, :file_path,
+                  :spec_name, :spec_path,
+                  :class_name, :route_name,
+                  :resource, :resources,
+                  :constant
+
+      def initialize(type, name)
+        type = type
+        @name = Inflect.send(type, name.to_s)
+        @file_name = "#{@name}.rb"
+        @file_path = File.join('app', type.to_s.pluralize, file_name)
+        @spec_name = "#{@name}_spec.rb"
+        @spec_path = File.join('spec', type.to_s.pluralize, spec_name)
+        @class_name = Inflect.constant(@name)
+        @route_name = Inflect.route(@name.gsub "_#{type}", '')
+        @resource = Inflect.resource(@route_name)
+        @resources = Inflect.resources(@route_name)
+        @constant = Inflect.constant(@route_name)
+      end
+    end
+  end
+end

data/lib/eucalypt/helpers/messages.rb

@@ -0,0 +1,31 @@
+require_relative 'colorize'
+module Eucalypt
+  module Helpers
+    module Messages
+      module Out
+        using Eucalypt::Helpers::Colorize
+        METHODS = {
+          warning: [:bold, :yellow],
+          error: [:bold, :red],
+          info: [:bold]
+        }
+
+        class << self
+          METHODS.each do |method, opts|
+            define_method "#{method}_message" do |message = String.new|
+              "#{method.to_s.upcase.colorize(*opts)}: #{message}"
+            end
+
+            define_method method do |message = String.new|
+              puts self.send("#{method}_message", message)
+            end
+          end
+
+          def setup(message = String.new)
+            puts "\n#{message.colorize(:bold, :blue)}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eucalypt/helpers/migration.rb

@@ -0,0 +1,85 @@
+require 'thor'
+require_relative 'messages'
+require 'eucalypt/errors'
+require 'eucalypt/helpers'
+
+module Eucalypt
+  module Helpers
+    class Migration < Thor
+      include Thor::Actions
+      include Eucalypt::Helpers
+      include Eucalypt::Helpers::Messages
+      using Colorize
+      attr_reader :title, :template, :file, :base, :file_path
+
+      class << self
+        alias_method :[], :new
+      end
+
+      no_tasks do
+        def initialize(title:, template:)
+          @title = title
+          @template = template
+          @file = Time.now.utc.strftime("%Y%m%d%H%M%S_#{title}.rb")
+          @base = File.join 'db', 'migrate'
+          @file_path = File.join @base, @file
+        end
+
+        def exists?
+          Dir[File.join @base, '*.rb'].any? {|f| f.include? @title}
+        end
+
+        def create_anyway?
+          %w[y Y Yes YES].include? create_anyway_prompt
+        end
+      end
+
+      class Validation
+        attr_reader :invalid_declarations, :invalid_types
+
+        COLUMN_TYPES = %i[
+          binary boolean date datetime decimal float integer
+          bigint primary_key references string text time timestamp
+        ]
+
+        DECLARATION_REGEX = /\A[A-Za-z0-9_]+\:[a-z_]+\Z/
+
+        def initialize(columns)
+          @invalid_declarations = []
+          @invalid_types = []
+
+          columns.each do |column|
+            if self.class.valid_declaration? column
+              col, type = column.split ?:
+              @invalid_types << {column: col, type: type} unless COLUMN_TYPES.include? type.to_sym
+            else
+              @invalid_declarations << column
+            end
+          end
+        end
+
+        def any_invalid?
+          any_invalid = @invalid_declarations.any? || @invalid_types.any?
+          Eucalypt::Error.invalid_columns(@invalid_declarations, @invalid_types) if any_invalid
+          return any_invalid
+        end
+
+        def self.valid_declaration?(column)
+          DECLARATION_REGEX.match? column
+        end
+
+        def self.valid_type?(type)
+          valid_type = COLUMN_TYPES.include? type.to_sym
+          Eucalypt::Error.invalid_type(type) unless valid_type
+          return valid_type
+        end
+      end
+
+      private
+
+      def create_anyway_prompt
+        ask Out.warning_message("A #{@title.colorize(:bold)} migration already exists. Create anyway?"), limited_to: %w[y Y Yes YES n N No NO]
+      end
+    end
+  end
+end

data/lib/eucalypt/helpers/numeric.rb

@@ -0,0 +1,10 @@
+module Eucalypt
+  module Helpers
+    module Numeric
+      def self.string?(string)
+        return true if string =~ /\A\d+\Z/
+        true if Float(string) rescue false
+      end
+    end
+  end
+end

data/lib/eucalypt/helpers.rb

@@ -0,0 +1,6 @@
+require_relative 'helpers/gemfile'
+require_relative 'helpers/migration'
+require_relative 'helpers/colorize'
+require_relative 'helpers/messages'
+require_relative 'helpers/inflect'
+require_relative 'helpers/numeric'

data/lib/eucalypt/list.rb

@@ -0,0 +1,39 @@
+require 'thor'
+require 'eucalypt/app'
+require 'eucalypt/helpers/colorize'
+
+module Eucalypt
+  module List
+    include Eucalypt::Helpers
+    using Colorize
+
+    INDENT = 2.freeze
+
+    def help(shell, subcommand = false)
+      list = printable_commands(true, subcommand)
+      Thor::Util.thor_classes_in(self).each do |klass|
+        list += klass.printable_commands(false)
+      end
+
+      list.reject! do |l|
+        cmd = l.first
+        cmd.include?('help') || cmd.include?('-H')
+      end
+      list.map {|l| l.last.sub!(?#, '·'.colorize(:pale_blue, :bold)+'›')}
+
+      if defined?(@package_name) && @package_name
+        shell.say "#{@package_name} commands:"
+      else
+        shell.say
+        shell.say "#{"Commands".colorize(:bold)}:"
+      end
+
+      shell.print_table(list, indent: INDENT, truncate: false)
+      shell.say
+      class_options_help(shell)
+
+      shell.say "For more information about a specific command, use #{"eucalypt -H".colorize(:pale_blue)}."
+      shell.say "Example: eucalypt -H generate scaffold".colorize(:grey)
+    end
+  end
+end

data/lib/eucalypt/static.rb

@@ -0,0 +1,48 @@
+require 'eucalypt/helpers/inflect'
+require 'json'
+require 'yaml'
+
+module Eucalypt
+  class Static
+    include Eucalypt::Helpers
+
+    FILE_TYPES = {yaml: %w[yml yaml], json: %w[json geojson]}
+
+    def initialize(directory, symbolize: false)
+      contents = Dir[File.join directory, '*']
+      files = contents.select {|f| File.file? f}
+      subdirectories = contents.select {|f| File.directory? f}
+      files.each {|f| define_file_accessor f, symbolize}
+      subdirectories.each {|s| define_subdirectory_accessor s, symbolize}
+    end
+
+    private
+
+    def define_file_accessor(file, symbolize)
+      file_name = File.basename file, '.*'
+      extension = File.extname(file).sub /\A./, ''
+      file_type = nil
+      FILE_TYPES.each {|t, e| file_type = t if e.include? extension}
+      raise TypeError.new("Unsupported extension: .#{extension}") if file_type.nil?
+      define_singleton_method Inflect.resource_keep_inflection(file_name) do
+        hash = parse(file_type, file)
+        hash = hash ? hash : {}
+        symbolize ? hash.deep_symbolize_keys : hash
+      end
+    end
+
+    def define_subdirectory_accessor(subdirectory, symbolize)
+      subdirectory_name = subdirectory.split(File::SEPARATOR).last
+      define_singleton_method Inflect.resource_keep_inflection(subdirectory_name) do
+        Static.new subdirectory, symbolize: symbolize
+      end
+    end
+
+    def parse(file_type, file)
+      case file_type
+      when :yaml then YAML.load_file(file)
+      when :json then JSON.parse(File.read file)
+      end
+    end
+  end
+end

data/lib/eucalypt/version.rb

@@ -0,0 +1,3 @@
+module Eucalypt
+  VERSION = '0.1.0'
+end

data/lib/eucalypt.rb

@@ -0,0 +1,19 @@
+require 'eucalypt/version'
+require 'eucalypt/eucalypt-core/cli/core'
+require 'eucalypt/eucalypt-blog/namespaces/blog/cli/blog'
+require 'eucalypt/eucalypt-generate/namespaces/generate/cli/generate'
+require 'eucalypt/eucalypt-destroy/namespaces/destroy/cli/destroy'
+require 'eucalypt/eucalypt-security/namespaces/security/cli/security'
+require 'eucalypt/eucalypt-migration/namespaces/migration/cli/migration'
+require 'eucalypt/static'
+require 'eucalypt/controller'
+require 'eucalypt/app'
+
+module Eucalypt
+  class CLI < Thor
+    class << self
+      require 'eucalypt/list'
+      include Eucalypt::List
+    end
+  end
+end