effective_developer 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c29066e84e43bb85a6bbb3b355537784ca8a8634
+  data.tar.gz: aa3035ca68b854b7f2b0416ca59b92680a07ae72
+SHA512:
+  metadata.gz: 412c6fe2018b272ef2a3208a25d3a5d9477414f1b02aa15718fcece18e3d82957cc12740078423f672ad4fcd6ed1a9b4eebb3964bbed108fd81e53cebe867746
+  data.tar.gz: 730983166244c70d25a519f97a69a5717bfbeff1f681d74c0cd824460bf6ecd5a3dfe34a37ba37848083e788ffec4f4a5f6e42644cc2f12d23f36936c5e6a25f

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 Code and Effect Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,121 @@
+# Effective Developer
+
+This is a small gem with some developer quality of life scripts.
+
+## Getting Started
+
+Add to your Gemfile:
+
+```ruby
+group :development
+  gem 'effective_developer'
+end
+```
+
+Run the bundle command to install it:
+
+```console
+bundle install
+```
+
+## gem_release
+
+A command line shell script that quickly bumps the version of any ruby gem.
+
+It checks for any uncommitted files, updates the gem's `version.rb` with the given version, makes a single file `git commit` with a tag and message, then runs `git push origin master`, `gem build` and `gem push` to rubygems.
+
+To use with any gem, add the following folder to your `PATH` (~/.bashrc or ~/.profile):
+
+```console
+export PATH="$PATH:$HOME/effective_developer/bin"
+```
+
+Once included in your `PATH`, `gem_release` should be run from the root directory of any ruby gem.
+
+To print the current gem version:
+
+```console
+> gem_release
+```
+
+To release a new gem version:
+
+```console
+> gem_release 1.0.0
+```
+
+## CSV Importer
+
+Extend a class from `Effective::CSVImporter` to quickly build a csv importer.
+
+Put your importer in `lib/csv_importers/users_importer.rb` and the data in `lib/csv_importers/data/users.csv`.  Both filenames should be pluralized.
+
+A rake command will be dynamically created `rake import:users`.
+
+### Required Methods
+
+The importer requires two instance methods be defined:
+
+- `def columns` a hash of names to columns.  The constants `A` == 0, `B` == 1, upto `AT` == 45 are defined to work better with spreadsheets.
+- `def process_row` will be run for each row of data.  Any exceptions will be caught and logged as errors.
+
+Inside the script, there are a few helpful functions:
+
+- `col(:email)` will return the normalized value in that column.
+- `last_row_col(:email)` will return the normalized value for this column in the previous row.
+- `raw_col(:email)` will return the raw value in that column
+
+```ruby
+module CsvImporters
+  class UsersImporter < Effective::CSVImporter
+    def columns
+      {
+        email: A,
+        first_name: B,
+        last_name: C,
+        admin?: D
+      }
+    end
+
+    def process_row
+      User.new(email: col(:email), first_name: col(:first_name), last_name: col(:last_name), admin: col(:admin?)).save!
+    end
+
+  end
+end
+```
+
+When using `col()` or `last_row_col()` helpers, the value is normalized.
+
+- Any column that ends with a `?` will be converted into a boolean.
+- Any column that ends with `_at` will be converted into a DateTime.
+- Any column that ends with `_on` will be converted into a Date.
+- Override `def normalize` to add your own.
+
+```ruby
+def normalize(column, value)
+  if column == :first_name
+    value.upcase
+  else
+    super
+  end
+end
+```
+
+Override `before_import()` or `after_import()` to run code before or after the import.
+
+## License
+
+MIT License.  Copyright [Code and Effect Inc.](http://www.codeandeffect.com/)
+
+Code and Effect is the product arm of [AgileStyle](http://www.agilestyle.com/), an Edmonton-based shop that specializes in building custom web applications with Ruby on Rails.
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Bonus points for test coverage
+6. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+Dir['lib/tasks/**/*.rake'].each { |ext| load ext } if defined?(Rake)

data/app/models/effective/access_denied.rb

@@ -0,0 +1,17 @@
+unless defined?(Effective::AccessDenied)
+  module Effective
+    class AccessDenied < StandardError
+      attr_reader :action, :subject
+
+      def initialize(message = nil, action = nil, subject = nil)
+        @message = message
+        @action = action
+        @subject = subject
+      end
+
+      def to_s
+        @message || I18n.t(:'unauthorized.default', :default => 'Access Denied')
+      end
+    end
+  end
+end

data/app/models/effective/csv_importer.rb

@@ -0,0 +1,131 @@
+require 'csv'
+
+module Effective
+  class CSVImporter
+    attr_reader :current_row, :last_row
+
+    A=0;B=1;C=2;D=3;E=4;F=5;G=6;H=7;I=8;J=9;K=10;L=11;M=12;N=13;
+    O=14;P=15;Q=16;R=17;S=18;T=19;U=20;V=21;W=22;X=23;Y=24;Z=25;
+    AA=26;AB=27;AC=28;AD=29;AE=30;AF=31;AG=32;AH=33;AI=34;AJ=35;
+    AK=36;AL=37;AM=38;AN=39;AO=40;AP=41;AQ=42;AR=43;AS=44;AT=45;
+
+    def initialize(csv_file, has_header_row = true)
+      @csv_file = csv_file.to_s
+      @has_header_row = has_header_row
+    end
+
+    def csv_file
+      @csv_file
+    end
+
+    def import!
+      log "Importing #{csv_file.split('/').last.sub('.csv', '')}"
+
+      @errors_count = 0
+
+      before_import()
+      with_each_row { process_row }
+      after_import()
+
+      log "Import complete (#{@errors_count} errors in #{@has_header_row ? @current_row_number-1 : @current_row_number} rows)"
+    end
+
+    def with_each_row(&block)
+      @current_row_number = (@has_header_row ? 2 : 1)
+
+      CSV.foreach(csv_file, headers: @has_header_row) do |row|
+        @current_row = row
+
+        begin
+          yield
+          print colorize('.', :green)
+        rescue => e
+          error(e.message)
+          puts row
+          puts e.backtrace.first(3)
+        end
+
+        @current_row_number += 1
+        @last_row = row
+      end
+    end
+
+    def columns
+      raise "Please define a method 'def columns' returning a Hash of {id: A, name: B}"
+    end
+
+    def process_row
+      raise "Please define a method 'def process_row' to process your row"
+    end
+
+    # Override me if you need some before/after hooks
+    def before_import ; end
+    def after_import ; end
+
+    # Normalize the value based on column name
+    def normalize(column, value)
+      column = column.to_s
+      value = value.to_s
+
+      if column.ends_with?('?')  # Boolean
+        ::ActiveRecord::ConnectionAdapters::Column::TRUE_VALUES.include?(value)
+      elsif column.ends_with?('_at')  # DateTime
+        Time.zone.parse(value) rescue nil
+      elsif column.ends_with?('_on')  # Date
+        Time.zone.parse(value).beginning_of_day rescue nil
+      else
+        value.presence || ''.freeze
+      end
+    end
+
+    def log(message)
+      puts "\n#{message}";
+    end
+
+    def error(message)
+      @errors_count += 1
+      puts "\n#{colorize('Error', :red)} (.csv line #{@current_row_number}) #{message}"
+    end
+
+    def warn(message)
+      puts "\n#{colorize('Warning', :yellow)} (.csv line #{@current_row_number}) #{message}"
+    end
+
+    protected
+
+    def col(column)
+      raise "unknown column :#{column} passed to col()" unless columns.key?(column) || column.kind_of?(Integer)
+
+      value = current_row[columns[column] || column].try(:strip).presence
+
+      normalize(column, value)
+    end
+
+    def raw_col(column)
+      raise "unknown column :#{column} passed to raw_col()" unless columns.key?(column) || column.kind_of?(Integer)
+      current_row[columns[column] || column]
+    end
+
+    def last_row_col(column)
+      raise "unknown column :#{column} passed to last_row_col()" unless columns.key?(column) || column.kind_of?(Integer)
+
+      value = last_row[columns[column] || column].try(:strip).presence
+
+      normalize(column, value)
+    end
+
+    def colorize(text, color)
+      code = case color
+        when :cyan    ; 36
+        when :magenta ; 35
+        when :blue    ; 34
+        when :yellow  ; 33
+        when :green   ; 32
+        when :red     ; 31
+        end
+
+      "\e[#{code}m#{text}\e[0m"
+    end
+
+  end
+end

data/config/effective_developer.rb

@@ -0,0 +1,4 @@
+# EffectiveDeveloper Rails Engine
+
+EffectiveDeveloper.setup do |config|
+end

data/lib/effective_developer/engine.rb

@@ -0,0 +1,11 @@
+module EffectiveDeveloper
+  class Engine < ::Rails::Engine
+    engine_name 'effective_developer'
+
+    # Set up our default configuration options.
+    initializer 'effective_developer.defaults', before: :load_config_initializers do |app|
+      # Set up our defaults, as per our initializer template
+      eval File.read("#{config.root}/config/effective_developer.rb")
+    end
+  end
+end

data/lib/effective_developer/version.rb

@@ -0,0 +1,3 @@
+module EffectiveDeveloper
+  VERSION = '0.0.2'.freeze
+end

data/lib/effective_developer.rb

@@ -0,0 +1,17 @@
+require 'effective_developer/engine'
+require 'effective_developer/version'
+
+module EffectiveDeveloper
+
+  def self.setup
+    yield self
+  end
+
+  def self.authorized?(controller, action, resource)
+    if authorization_method.respond_to?(:call) || authorization_method.kind_of?(Symbol)
+      raise Effective::AccessDenied.new() unless (controller || self).instance_exec(controller, action, resource, &authorization_method)
+    end
+    true
+  end
+
+end

data/lib/generators/effective_developer/install_generator.rb

@@ -0,0 +1,16 @@
+module EffectiveDeveloper
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      desc 'Creates an EffectiveDeveloper initializer in your application.'
+
+      source_root File.expand_path(('../' * 4), __FILE__)
+
+      def copy_initializer
+        template 'config/effective_developer.rb', 'config/initializers/effective_developer.rb'
+      end
+
+    end
+  end
+end

data/lib/tasks/effective_csv_importer.rake

@@ -0,0 +1,46 @@
+# effective_csv_importer 1.0
+
+# Creates one rake task per importer model, as well as a `rake import:all` task.
+
+# Usage:
+
+# Put your importer in /lib/csv_importers/posts.rb
+# Put your csv data in /lib/csv_importers/data/posts.csv
+# Both filenames should be pluralized
+
+# rake import:posts (one task created per model)
+# rake import:all
+
+namespace :import do
+  Dir['lib/csv_importers/*.rb'].each do |file|
+    importer = file.sub('lib/csv_importers/', '').sub('_importer.rb', '')
+    csv_file = "lib/csv_importers/data/#{importer}.csv"
+    next unless File.exists?(csv_file)
+
+    # Create a rake task to import this file
+    desc "Import #{importer} from #{csv_file}"
+
+    task importer => :environment do
+      klass = "CsvImporters::#{importer.classify.pluralize}Importer".safe_constantize
+      raise "unable to constantize CsvImporters::#{importer.classify.pluralize}Importer for #{file}" unless klass
+
+      klass.new(csv_file).import!
+    end
+  end
+end
+
+# This task is kind of naive, because some imports could be order dependent. Use at your own risk.
+namespace :import do
+  desc "Import all from /lib/csv_importers/*.rb"
+
+  task :all => :environment do
+    Dir['lib/csv_importers/*.rb'].each do |file|
+      importer = file.sub('lib/csv_importers/', '').sub('_importer.rb', '')
+      csv_file = "lib/csv_importers/data/#{importer}.csv"
+      next unless File.exists?(csv_file)
+
+      Rake::Task["import:#{importer}"].invoke
+    end
+  end
+
+end

data/lib/tasks/pg_pull.rake

@@ -0,0 +1,66 @@
+namespace :pg do
+  # Creates a new backup on heroku, downloads that backup to latest.dump, and then calls pg:load
+  #
+  # bundle exec rake pg:pull
+  # bundle exec rake pg:pull[staging]
+  desc 'Pulls a newly captured backup from heroku (--remote heroku by default) and calls pg:load'
+  task :pull, [:remote] => :environment do |t, args|
+    args.with_defaults(:remote => 'heroku')
+
+    puts "=== Pulling remote '#{args.remote}' database into latest.dump"
+
+    Bundler.with_clean_env do
+      unless system("heroku pg:backups capture --remote #{args.remote}")
+        puts "Error capturing backup"
+        exit
+      end
+
+      if system("curl -o latest.dump `heroku pg:backups public-url --remote #{args.remote}`")
+        puts "Downloading database completed"
+      else
+        puts "Error downloading database"
+        exit
+      end
+    end
+
+    Rake::Task['pg:load'].invoke
+  end
+
+  # Drops and re-creates the local database then initializes database with latest.dump
+  #
+  # bundle exec rake pg:load => Will replace the current database with latest.dump
+  # bundle exec rake pg:load[something.dump] => Will replace the current database with latest.dump
+  desc 'Loads a postgresql .dump file into the development database (latest.dump by default)'
+  task :load, [:file_name] => :environment do |t, args|
+    args.with_defaults(:file_name => 'latest.dump')
+    db = ActiveRecord::Base.configurations
+
+    puts "=== Loading #{args.file_name} into local '#{db[Rails.env]['database']}' database"
+
+    Rake::Task['db:drop'].invoke
+    Rake::Task['db:create'].invoke
+
+    if system("pg_restore --no-acl --no-owner -h localhost -U #{db[Rails.env]['username']} -d #{db[Rails.env]['database']} #{args.file_name}")
+      puts "Loading database completed"
+    else
+      puts "Error loading database"
+    end
+  end
+
+  # bundle exec rake pg:save => Will dump the database to latest.dump
+  # bundle exec rake pg:save[something.dump] => Will dump the database to something.dump
+  desc 'Saves the development database to a postgresql .dump file (latest.dump by default)'
+  task :save, [:file_name] => :environment do |t, args|
+    args.with_defaults(:file_name => 'latest.dump')
+    db = ActiveRecord::Base.configurations
+
+    puts "=== Saving local '#{db[Rails.env]['database']}' database to #{args.file_name}"
+
+    if system("pg_dump -Fc --no-acl --no-owner -h localhost -U '#{db[Rails.env]['username']}' '#{db[Rails.env]['database']}' > #{args.file_name}")
+      puts "Saving database completed"
+    else
+      puts "Error saving postgres database"
+    end
+  end
+
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: effective_developer
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Code and Effect
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-04-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+description: Provides some quality of life developer tools.
+email:
+- info@codeandeffect.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/models/effective/access_denied.rb
+- app/models/effective/csv_importer.rb
+- config/effective_developer.rb
+- lib/effective_developer.rb
+- lib/effective_developer/engine.rb
+- lib/effective_developer/version.rb
+- lib/generators/effective_developer/install_generator.rb
+- lib/tasks/effective_csv_importer.rake
+- lib/tasks/pg_pull.rake
+homepage: https://github.com/code-and-effect/effective_developer
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Provides some quality of life developer tools.
+test_files: []