napa 0.1.0

data/lib/napa/logger/logger.rb

@@ -0,0 +1,34 @@
+module Napa
+  class Logger
+    class << self
+      def name
+        [Napa::Identity.name, Napa::LogTransaction.id].join('-')
+      end
+
+      def logger=(logger)
+        @logger = logger
+      end
+
+      def logger
+        unless @logger
+          Logging.appenders.stdout(
+            'stdout',
+            :layout => Logging.layouts.json
+          )
+          Logging.appenders.file(
+            "log/#{Napa.env}.log",
+            :layout => Logging.layouts.json
+          )
+
+          @logger = Logging.logger["[#{name}]"]
+          unless Napa.env.test?
+            @logger.add_appenders 'stdout'
+          end
+          @logger.add_appenders "log/#{Napa.env}.log"
+        end
+
+        @logger
+      end
+    end
+  end
+end

data/lib/napa/middleware/app_monitor.rb

@@ -0,0 +1,17 @@
+module Napa
+  class Middleware
+    class AppMonitor
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        if env['REQUEST_PATH'] == '/health'
+          [200, {'Content-type' => 'application/json'}, [Napa::Identity.health.to_json]]
+        else
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/napa/middleware/logger.rb

@@ -0,0 +1,69 @@
+module Napa
+  class Middleware
+    class Logger
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        # set transaction_id
+        transaction_id=SecureRandom.uuid
+
+        # log the request
+        Napa::Logger.logger.debug format_request(env)
+
+        # process the request
+        status, headers, body = @app.call(env)
+
+        # log the response
+        Napa::Logger.logger.debug format_response(status, headers, body)
+
+        # return the results
+        [status, headers, body]
+      ensure
+        # Clear the transaction id after each request
+        Napa::LogTransaction.clear
+      end
+
+    private
+      def format_request(env)
+        request = Rack::Request.new(env)
+        params =  request.params
+        begin
+          params = JSON.parse(request.body.read) if env['CONTENT_TYPE'] == 'application/json'
+        rescue
+          # do nothing, params is already set
+        end
+
+        request_data = {
+          method:           env['REQUEST_METHOD'],
+          path:             env['PATH_INFO'],
+          query:            env['QUERY_STRING'],
+          host:             Napa::Identity.hostname,
+          pid:              Napa::Identity.pid,
+          revision:         Napa::Identity.revision,
+          params:           params
+        }
+        request_data[:user_id] = current_user.try(:id) if defined?(current_user)
+        {request: request_data}
+      end
+
+      def format_response(status, headers, body)
+        response_body = nil
+        begin
+          response_body = body.respond_to?(:body) ? body.body.map{|r| r} : nil
+        rescue
+          response_body = body.inspect
+        end
+        
+        {response:
+          {
+            status:   status,
+            headers:  headers,
+            response: response_body
+          }
+        }
+      end
+    end
+  end
+end

data/lib/napa/version.rb

@@ -0,0 +1,45 @@
+module Napa
+  VERSION = "0.1.0"
+
+  class Version
+    class << self
+      def next_major
+        self.next_level(:major)
+      end
+
+      def next_minor
+        self.next_level(:minor)
+      end
+
+      def next_patch
+        self.next_level(:patch)
+      end
+
+      def next_level(level)
+        raise "Unidentified Level" unless [:major,:minor,:patch].include?(level)
+
+        parts = Napa::VERSION.split('.').map{|p| p.to_i}
+
+        if level == :major
+          parts[0] += 1 
+          significant_index = 1
+        end
+
+        if level == :minor
+          parts[1] += 1 
+          significant_index = 2    
+        end
+
+        if level == :patch
+          parts[2] += 1 
+          significant_index = 3
+        end
+
+        parts.map.with_index{|p,i| parts[i] = 0 if i >= significant_index}
+
+        parts.join('.')
+      end
+
+    end
+  end
+end

data/lib/napa.rb

@@ -0,0 +1,37 @@
+# require external libraries
+require 'rake'
+require 'dotenv'
+require 'logging'
+require 'octokit'
+require 'grape'
+
+# require internal files
+require "napa/version"
+require "napa/logger/logger"
+require "napa/logger/log_transaction"
+require "napa/identity"
+require "napa/middleware/logger"
+require "napa/middleware/app_monitor"
+require "napa/activerecord"
+require "napa/grape_api"
+require "generators/scaffold"
+
+# load rake tasks if Rake installed
+if defined?(Rake)
+	load 'tasks/git.rake'
+  load 'tasks/deploy.rake'
+  load 'tasks/routes.rake'
+  load 'tasks/db.rake'
+end
+
+module Napa
+  class << self
+    def env
+      @_env ||= ActiveSupport::StringInquirer.new(ENV["RACK_ENV"] || "development")
+    end
+
+    def env=(environment)
+      @_env = ActiveSupport::StringInquirer.new(environment)
+    end
+  end
+end

data/lib/tasks/db.rake

@@ -0,0 +1,87 @@
+task :environment do
+  require 'erb'  
+  require './app'
+
+  raise "ActiveRecord Not Found" unless Module.const_defined?(:ActiveRecord)
+end
+
+namespace :db do
+  desc "Migrate the database through scripts in db/migrate. Target specific version with VERSION=x"
+  task :migrate => :environment do
+    ActiveRecord::Migrator.migrate('db/migrate', ENV["VERSION"] ? ENV["VERSION"].to_i : nil )
+    Rake::Task["db:schema:dump"].invoke
+  end
+
+  desc "Create the database"
+  task :create => :environment do
+    db = YAML.load(ERB.new(File.read('./config/database.yml')).result)[Napa.env]
+    adapter = db.merge({'database'=> 'mysql'})
+    ActiveRecord::Base.establish_connection(adapter)
+    ActiveRecord::Base.connection.create_database(db.fetch('database'))
+  end
+
+  desc "Delete the database"
+  task :drop => :environment do
+    db = YAML.load(ERB.new(File.read('./config/database.yml')).result)[Napa.env]
+    adapter = db.merge({'database'=> 'mysql'})
+    ActiveRecord::Base.establish_connection(adapter)
+    ActiveRecord::Base.connection.drop_database(db.fetch('database'))
+  end
+
+  desc "Create the test database"
+  task :reset => :environment do  
+    Rake::Task["db:drop"].invoke
+    Rake::Task["db:create"].invoke
+    Rake::Task["db:schema:load"].invoke
+  end
+
+  namespace :generate do
+    desc "Generate a migration with given name. Specify migration name with NAME=my_migration_name"
+    task :migration => :environment do
+      raise "Please specify desired migration name with NAME=my_migration_name" unless ENV['NAME']
+      
+      # Find migration name from env
+      migration_name = ENV['NAME'].strip.chomp
+      
+      # Define migrations path (needed later)
+      migrations_path = './db/migrate'
+            
+      # Find the highest existing migration version or set to 1
+      if (existing_migrations = Dir[File.join(migrations_path, '*.rb')]).length > 0
+        version = File.basename(existing_migrations.sort.reverse.first)[/^(\d+)_/,1].to_i + 1
+      else
+        version = 1
+      end
+      
+      # Use the migration template to fill the body of the migration
+      migration_content = Napa::ActiveRecord.migration_template(migration_name.camelize)
+      
+      # Generate migration filename
+      migration_filename = "#{"%03d" % version}_#{migration_name}.rb"
+      
+      # Write the migration
+      File.open(File.join(migrations_path, migration_filename), "w+") do |migration|
+        migration.puts migration_content
+      end
+      
+      # Done!
+      puts "Successfully created migration #{migration_filename}"
+    end
+  end
+  
+  namespace :schema do
+    desc "Create a db/schema.rb file that can be portably used against any DB supported by AR"
+    task :dump => :environment do
+      require 'active_record/schema_dumper'
+      File.open(ENV['SCHEMA'] || "db/schema.rb", "w") do |file|
+        ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
+      end
+    end
+ 
+    desc "Load a schema.rb file into the database"
+    task :load => :environment do
+      file = ENV['SCHEMA'] || "db/schema.rb"
+      load(file)
+    end
+  end
+end

data/lib/tasks/deploy.rake

@@ -0,0 +1,13 @@
+namespace :deploy do
+  desc "Deploy to production"
+  task :production do
+    Rake::Task["git:verify"].invoke
+    Rake::Task["git:set_tag"].invoke
+  end
+
+  desc "Deploy to staging"
+  task :staging do
+    Rake::Task["git:verify"].invoke
+    Rake::Task["git:set_tag"].invoke("staging")
+  end
+end

data/lib/tasks/git.rake

@@ -0,0 +1,50 @@
+namespace :git do
+  client = Octokit::Client.new(:oauth_token => ENV['GITHUB_OAUTH_TOKEN'])
+  logger = Logger.new(STDOUT)
+
+  github_repo = ENV['GITHUB_REPO']
+  local_sha = `git rev-parse HEAD`.strip
+
+  desc "Verify git repository is in a good state for deployment"
+  task :verify do
+    logger.info "Verifying git repository is in a good state"
+
+    # Be sure local HEAD exists on remote
+    begin
+      remote_commit = client.commit(github_repo, local_sha)
+    rescue Octokit::NotFound
+      raise RuntimeError, "Local commit #{local_sha} does not exist on remote. Be sure to push your changes."
+    end
+
+    # Check for uncommited changes
+    unless(system("git diff --quiet HEAD"))
+      raise RuntimeError, "You have uncommited changes. Either commit or stash them before continuing."
+    end
+
+    # Check for untracked files
+    unless(`git status --porcelain | grep '^??' | wc -l`.strip == "0")
+      raise RuntimeError, "You have untracked files. Either commit or remove them before continuing."
+    end
+  end
+
+  desc "Set tag, which triggers deploy"
+  task :set_tag, :tag do |t, args|
+    tag = args[:tag] || "production"
+    logger.info "Setting #{tag} tag on github"
+
+    # Update ref, create ref if it doesn't exist
+    begin
+      client.update_ref(
+        github_repo,
+        "tags/#{tag}",
+        local_sha
+      )
+    rescue Octokit::UnprocessableEntity
+      client.create_ref(
+        github_repo,
+        "tags/#{tag}",
+        local_sha
+      )
+    end
+  end
+end

data/lib/tasks/routes.rake

@@ -0,0 +1,9 @@
+desc "display all routes"
+task :routes do
+  grape_apis = ObjectSpace.each_object(Class).select { |klass| klass < Grape::API }
+  grape_apis.each do |api|
+    api.routes.each do |r|
+      puts "#{r}"
+    end
+  end
+end

data/napa.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/napa/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Darby Frey"]
+  gem.email         = ["darby@bellycard.com"]
+  gem.description   = %q{A simple framework for building APIs with Grape}
+  gem.summary       = %q{A simple framework for building APIs with Grape}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   << 'napa'
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "napa"
+  gem.require_paths = ["lib"]
+  gem.version       = Napa::VERSION
+
+
+  gem.add_dependency 'rake'
+  gem.add_dependency 'logging'
+  gem.add_dependency 'dotenv'
+  gem.add_dependency 'octokit', '~> 1.25'
+  gem.add_dependency 'virtus', '0.5.5'
+  gem.add_dependency 'grape'
+  gem.add_dependency 'grape-swagger'
+  gem.add_dependency 'unicorn'
+
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "pry"
+  gem.add_development_dependency "git"
+end

data/spec/identity_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'napa/identity'
+
+describe Napa::Identity do
+  context "#name" do
+    it "returns 'api-service' if no ENV['SERVICE_NAME'] is set" do
+      ENV['SERVICE_NAME'] = nil
+      Napa::Identity.name.should == 'api-service'
+    end
+
+    it "returns the ENV['SERVICE_NAME'] when specified" do
+      ENV['SERVICE_NAME'] = nil
+      ENV['SERVICE_NAME'] = 'my-service'
+      Napa::Identity.name.should == 'my-service'
+    end
+  end
+
+  context "#hostname" do
+    it "returns the value of the hostname system call and doesn't make a second system call" do
+      Napa::Identity.should_receive(:`).with("hostname").and_return("system-hostname")
+      Napa::Identity.hostname.should == 'system-hostname'
+
+      Napa::Identity.should_not_receive(:`).with("hostname")
+      Napa::Identity.hostname.should == 'system-hostname'
+    end
+  end
+
+  context "#revision" do
+    it "returns the value of the 'git rev-parse HEAD' system call and doesn't make a second system call" do
+      Napa::Identity.should_receive(:`).with("git rev-parse HEAD").and_return("12345")
+      Napa::Identity.revision.should == '12345'
+
+      Napa::Identity.should_not_receive(:`).with("git rev-parse HEAD")
+      Napa::Identity.revision.should == '12345'
+    end
+  end
+
+  context "#pid" do
+    it "returns the process ID value" do
+      Process.stub(:pid).and_return(112233)
+      Napa::Identity.pid.should == 112233
+    end
+  end
+
+  context "#platform_revision" do
+    it "returns the current version of the platform gem" do
+      Napa::Identity.platform_revision.should == Napa::VERSION
+    end
+  end
+end

data/spec/logger/log_transaction_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'napa/logger/log_transaction'
+
+describe Napa::LogTransaction do
+  before(:each) do
+    Napa::LogTransaction.clear
+  end
+
+  context "#id" do
+    it "returns the current transaction id if it has been set" do
+      id = SecureRandom.hex(10)
+      Thread.current[:napa_tid] = id
+      Napa::LogTransaction.id.should == id
+    end
+
+    it "sets and returns a new id if the transaction id hasn't been set" do
+      Napa::LogTransaction.id.should_not be_nil
+    end
+
+    it "allows the id to be overridden by a setter" do
+      Napa::LogTransaction.id.should_not be_nil
+      Napa::LogTransaction.id = 'foo'
+      Napa::LogTransaction.id.should == 'foo'
+    end
+  end
+
+  context "#clear" do
+    it "sets the id to nil" do
+      Napa::LogTransaction.id.should_not be_nil
+      Napa::LogTransaction.clear
+      Thread.current[:napa_tid].should be_nil
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'napa'

data/spec/version_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'napa/version'
+
+describe Napa::Version do
+  context "#major_bump" do
+    it "should set the major revision value, and the rest should be 0" do
+      stub_const("Napa::VERSION", "1.2.3")
+      Napa::Version.next_major.should == "2.0.0"
+    end
+
+    it "should set the major revision value, and the rest should be 0" do
+      stub_const("Napa::VERSION", "5.0.0")
+      Napa::Version.next_major.should == "6.0.0"
+    end
+  end
+
+  context "#minor_bump" do
+    it "should set the minor revision value, leaving the major value unchanged and the patch value to 0" do
+      stub_const("Napa::VERSION", "1.2.3")
+      Napa::Version.next_minor.should == "1.3.0"
+    end
+
+    it "should set the minor revision value, leaving the major value unchanged and the patch value to 0" do
+      stub_const("Napa::VERSION", "0.5.0")
+      Napa::Version.next_minor.should == "0.6.0"
+    end
+  end
+
+  context "patch_bump" do
+    it "should set the patch revision value, leaving the major and minor values unchanged" do
+      stub_const("Napa::VERSION", "1.2.3")
+      Napa::Version.next_patch.should == "1.2.4"
+    end
+
+    it "should set the patch revision value, leaving the major and minor values unchanged" do
+      stub_const("Napa::VERSION", "5.5.5")
+      Napa::Version.next_patch.should == "5.5.6"
+    end
+  end
+end

data/tasks/version.rake

@@ -0,0 +1,51 @@
+desc "bump the gem version"
+namespace :version do
+  namespace :bump do
+
+    task :major do
+      @new_version = Napa::Version.next_major
+      execute_version_bump
+    end
+
+    task :minor do
+      @new_version = Napa::Version.next_minor
+      execute_version_bump
+    end
+
+    task :patch do
+      @new_version = Napa::Version.next_patch
+      execute_version_bump
+    end
+
+    def execute_version_bump
+      if !clean_staging_area?
+        system "git status"
+        raise "Unclean staging area! Be sure to commit or .gitignore everything first. See `git status` above."
+      else
+        require 'git'
+        git = Git.open('.')
+
+        write_update
+        git.add('lib/napa/version.rb')
+        git.commit("Version bump: #{release_tag}")
+        git.add_tag(release_tag)
+        git.push(git.remote('origin'), git.branch, release_tag) if git.remote('origin')
+        puts "Version bumped: #{release_tag}"
+      end
+    end
+
+    def write_update
+      filedata = File.read('lib/napa/version.rb')
+      changed_filedata = filedata.gsub("VERSION = \"#{Napa::VERSION}\"\n", "VERSION = \"#{@new_version}\"\n")
+      File.open('lib/napa/version.rb',"w"){|file| file.puts changed_filedata}
+    end
+
+    def clean_staging_area?
+      `git ls-files --deleted --modified --others --exclude-standard` == ""
+    end
+
+    def release_tag
+      "v#{@new_version}"
+    end
+  end
+end