figs 0.1.0 → 1.2.1

data/Gemfile

@@ -0,0 +1,10 @@
+source "https://rubygems.org"
+
+gemspec
+
+group :test do
+  gem "aruba", "~> 0.5"
+  gem "coveralls", "~> 0.7", require: false
+  gem "rspec", "~> 2.14"
+end
+gem 'git'

data/README.md

@@ -0,0 +1,62 @@
+## Figs
+[![Gem Version](https://badge.fury.io/rb/figs.png)](http://badge.fury.io/rb/figs)
+[![Build Status](https://travis-ci.org/NYULibraries/figs.png?branch=master)](https://travis-ci.org/NYULibraries/figs)
+[![Code Climate](https://codeclimate.com/github/NYULibraries/figs.png)](https://codeclimate.com/github/NYULibraries/figs)
+[![Coverage Status](https://coveralls.io/repos/NYULibraries/figs/badge.png)](https://coveralls.io/r/NYULibraries/figs)
+[![Dependency Status](https://gemnasium.com/NYULibraries/figs.png)](https://gemnasium.com/NYULibraries/figs)
+
+Railsless, herokuless, configurable, barebones figaro with a knack of using git repos for configuration files.
+
+Simple app configuration
+
+## What is this for?
+
+Figs is for configuring apps, especially open source apps, much like Figaro. Whereas Figaro is great in that it works seamlessly with Rails 3 and 4, Figs also works with non Rails apps providing the same great ENV support, although in a slightly different way.
+
+However, much like Figaro, Figs allows you to Open Source your app while keeping private things private.
+
+## How does it work?
+
+Figs is identical to Figaro in every way barring a few key differences. It uses `ENV` to store any string key-value pairs. However, sometimes its necessary to store more complex objects, such as arrays. `ENV` doesn't allow for objects, so we provide a souped-up wrapper called `Figs::Env` for this purpose! All keys are converted to strings and all non-string values are marshalled and stored in `ENV`, you can demarshall them yourself using `ENV` or rely on `Figs::Env.key_name` to do it fast and easy!
+
+## Example.
+
+Add Figs to your Gemfile then `bundle` command to install it:
+
+```ruby
+gem "figs"
+```
+
+Then you'll have to figsify your project so Figs can find where you keep your environment variables. If a location is not specified, a template will be created in the root directory as application.yml.
+
+```
+figsify
+```
+or
+
+```
+figsify config/settings1.yml config/settings2.yml config/settings3.yml
+```
+And finally 
+
+```
+figsify git@github.com:GITHUBNAME/REPONAME.git filename1.yml config/filename2.yml
+```
+
+Now Figs will know where to find your environment vars!
+
+__IMPORTANT:__ The order in which you load your files matters, as the environment variables perform a merge on the hashes, the right hand arguments taking precedence.
+
+Then in ruby
+
+```ruby
+Figs.load()
+
+Settings.secret = ENV["SECRET"]
+# OR
+Settings.servers = Figs.env["server"]
+```
+
+## Thank you!
+
+Figs was made possible by the kind folks at [Figaro](https://github.com/laserlemon/figaro)

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/figsify

@@ -3,7 +3,9 @@
 require "figs/install"
 
 if ARGV.length > 1
-  abort "Too many arguments; please specify only the yaml file location/git repo."
+  join = ARGV.join(",")
+  ARGV.clear
+  ARGV.push join
 end
 
 ARGV.push "install[#{ARGV.pop}]"

data/lib/figs/application.rb

@@ -0,0 +1,124 @@
+require "erb"
+require "yaml"
+
+require "figs/error"
+require "figs/env"
+require "figs/git_handler"
+
+module Figs
+  class Application
+    FIGS_ENV_PREFIX = "_FIGS_"
+
+    include Enumerable
+
+    attr_writer :stage, :path
+
+    def initialize(options = {})
+      @figfile = options[:file]
+      @stage = options[:stage]
+      load_path
+    end
+    
+    def locations
+      figfile["locations"]
+    end
+    
+    def load_path
+      if figfile["method"].eql? "git"
+        @path = path_from_git(figfile["repo"], figfile["locations"])
+      else
+        @path = figfile["locations"]
+      end
+    end
+    
+    def path_from_git(git_path, filenames = nil)
+      if(locations.is_a?(Array))
+        Figs::GitHandler.location(git_path, filenames)
+      else
+        Figs::GitHandler.location(git_path, @stage)
+      end
+    end
+    
+    def figfile
+      (@figfile || default_figfile)
+    end
+
+    def path
+      (@path || default_path)
+    end
+
+    def stage
+      (@stage || default_stage).to_s
+    end
+
+    def configuration
+      global_configuration.merge(stage_configuration)
+    end
+
+    def load
+      each do |key, value|
+        set(key, value) unless skip?(key)
+      end
+    ensure
+      Figs::GitHandler.clear_temp_files
+    end
+    
+    def env
+      Figs::ENV
+    end
+
+    def each(&block)
+      configuration.each(&block)
+    end
+
+    private
+
+    def default_path
+      raise NotImplementedError
+    end
+
+    def default_stage
+      "test"
+    end
+    
+    def default_figfile
+      raise NotImplementedError
+    end
+
+    def raw_configuration
+      (@parsed ||= Hash.new { |hash, path| hash[path] = parse(path) })[path]
+    end
+
+    def parse_path(path)
+      File.exist?(path) && YAML.load(ERB.new(File.read(path)).result) || {}
+    end
+    
+    def parse(paths)
+      parse = {}
+      paths.is_a?(Array) ? paths.each { |path| parse.merge!(parse_path(path)) } : parse.merge!(parse_path(paths))
+      parse
+    end
+
+    def global_configuration
+      raw_configuration.reject { |key, value| key.to_s.eql?(stage) && value.is_a?(Hash) }
+    end
+
+    def stage_configuration
+      raw_configuration.fetch(stage) { {} }
+    end
+
+    def set(key, value)
+      # FigsFigs::ENV.set_array(key, value) unless !value.is_a?(Array)
+      Figs::ENV[key] = value
+      Figs::ENV[FIGS_ENV_PREFIX + key.to_s] = value
+    end
+
+    def skip?(key)
+      Figs::ENV.key?(key.to_s) && !Figs::ENV.key?(FIGS_ENV_PREFIX + key.to_s)
+    end
+
+    def non_string_configuration!(value)
+        warn "WARNING: Use strings for Fig configuration. #{value.inspect} was converted to #{value.to_s.inspect}."
+    end
+  end
+end

data/lib/figs/env.rb

@@ -0,0 +1,65 @@
+require 'hashie'
+module Figs
+  module ENV
+    extend self
+    
+    def env
+     @env ||= ::ENV
+    end
+    
+    def set(key,value)
+      env[key.to_s] = value.is_a?(String) ? value : YAML::dump(value)
+    end
+    
+    def [](key)
+      return demarshall(env[key.to_s])
+    end
+    
+    def []=(key,value)
+      set(key, value)
+    end
+    
+    def demarshall(value)
+      value.nil? ? nil : YAML::load(value)
+    end
+    
+    def method_missing(method, *args, &block)
+      if matches_env?(method) then return env.send(method, *args, &block) end
+      
+      key, punctuation = extract_key_from_method(method)
+      _, value = env.detect { |k, _| k.upcase == key }
+      
+      value = demarshall(value)
+
+      case punctuation
+      when "!" then value || missing_key!(key)
+      when "?" then !!value
+      when nil then value
+      else super
+      end
+    end
+
+    def extract_key_from_method(method)
+      method.to_s.upcase.match(/^(.+?)([!?=])?$/).captures
+    end
+
+    def missing_key!(key)
+      raise MissingKey.new("Missing required Figaro configuration key #{key.inspect}.")
+    end
+    
+    def respond_to?(method, *)
+      return true if matches_env?(method)
+      key, punctuation = extract_key_from_method(method)
+
+      case punctuation
+      when "!" then env.keys.any? { |k| k.upcase == key } || super
+      when "?", nil then true
+      else super
+      end
+    end
+    
+    def matches_env?(method)
+      env.respond_to?(method)
+    end
+  end
+end

data/lib/figs/error.rb

@@ -0,0 +1,4 @@
+module Figs
+  class Error < StandardError; end
+  class MissingKey < Error; end
+end

data/lib/figs/figfile.rb

@@ -0,0 +1,14 @@
+module Figs
+  class Figfile
+    attr_reader :locations, :method, :repo
+    def initialize(*args)
+      @repo = args.shift if args.first.downcase.end_with?(".git")
+      @locations = args
+      @method = @repo.nil? ? "path" : "git"
+    end
+    
+    def [](key)
+      send key
+    end
+  end
+end

data/lib/figs/git_handler.rb

@@ -0,0 +1,49 @@
+require "git"
+
+module Figs
+  module GitHandler
+    extend self
+    TMP_GIT_DIR = "tmp/figs/"
+
+    def location(gitpath, filenames)
+      @temp_files = []
+      git_clone gitpath
+      temp_filenames(([]<< filenames).flatten)
+    rescue
+      clear_tmp_dir
+      clear_temp_files
+    end
+    
+    def clear_temp_files
+      return unless !@temp_files.nil?
+      @temp_files.each { |temp_file| temp_file.close temp_file.unlink }
+    end
+    
+    private
+    
+    def temp_filenames(filenames)
+      temp_files = []
+      filenames.each { |filename| temp_files << copy_to_temp_files(filename) }
+      clear_tmp_dir
+      temp_files
+    end
+    
+    def copy_to_temp_files(filename)
+      temp_file = Tempfile.new("#{filename}")
+      temp_file.open
+      temp_file.write(File.open("#{TMP_GIT_DIR}#{filename}").read)
+      temp_file.flush
+      @temp_files << temp_file
+      temp_file.path
+    end
+    
+    def git_clone(gitpath)
+      clear_tmp_dir
+      ::Git.clone gitpath, TMP_GIT_DIR
+    end
+    
+    def clear_tmp_dir
+      FileUtils.rm_rf TMP_GIT_DIR
+    end
+  end
+end

data/lib/figs/install.rb

@@ -0,0 +1,28 @@
+require "erb"
+require "yaml"
+
+require "figs/error"
+require 'rake'
+
+
+
+module Figs
+  class Install < Rake::Application
+    
+    def initialize
+      super
+      
+      @name = "figs"
+      @rakefiles = [File.expand_path(File.join(File.dirname(__FILE__),'tasks/install.rake'))]
+    end
+    
+    def run
+      Rake.application = self
+      super
+    end
+    
+    def default_task_name
+      "install"
+    end
+  end
+end

data/lib/figs/tasks/install.rake

@@ -0,0 +1,34 @@
+require 'erb'
+require 'pathname'
+require 'figs/figfile'
+desc 'Install Fig'
+task :install do |task, args|
+  base_dir = Pathname.new('.')
+  locations = args.extras.empty? ? "application.yml" :  args.extras
+  figfile = Figs::Figfile.new(*locations)
+  
+  create_figfile base_dir, figfile
+  create_non_existent_yaml(figfile.locations) if figfile.method.eql?("path")
+  
+  puts "[Done] Enjoy your figs sir!"
+end
+
+def create_figfile(base_dir, figfile)
+  puts "Figsifying #{base_dir}/ ..."
+  file = base_dir.join('Figfile')
+  File.open(file, 'w+') do |f|
+    f.write(figfile.to_yaml)
+  end
+end
+
+def create_non_existent_yaml(locations)
+  locations.each do |file|
+    if !File.exists?(file)
+      puts "[Add] #{file} does not exist, creating."
+      application_yml = File.expand_path("../../templates/application.yml", __FILE__)
+      File.open(file, 'w+') do |f|
+        f.write(ERB.new(File.read(application_yml)).result(binding))
+      end
+    end
+  end
+end

data/lib/figs/templates/application.yml

@@ -0,0 +1,7 @@
+# Add application configuration variables here, as shown below.
+#
+# PUSHER_APP_ID: "2954"
+# PUSHER_KEY: 7381a978f7dd7f9a1117
+# PUSHER_SECRET: abdc3b896a0ffb85d373
+# STRIPE_API_KEY: EdAvEPVEC3LuaTg5Q3z6WbDVqZlcBQ8Z
+# STRIPE_PUBLIC_KEY: pk_BRgD57O8fHja9HxduJUszhef6jCyS

data/lib/figs/version.rb

@@ -0,0 +1,3 @@
+module Figs
+  VERSION = "1.2.1"
+end

data/lib/figs.rb

@@ -0,0 +1,31 @@
+require "figs/application"
+require "figs/env"
+require "figs/figfile"
+
+module Figs
+  extend self
+
+  attr_writer :backend, :application
+
+  def env
+    application.env
+  end
+  
+  def backend
+    @backend ||= Figs::Application
+  end
+
+  def application(options = {})
+    @application ||= backend.new({:file => figfile, :stage => options[:stage]})
+  end
+
+  def load(options = {})
+    application({:stage => options[:stage]}).load
+  end
+  
+  private
+  
+  def figfile
+    @figfile ||=YAML.load(ERB.new(File.read('Figfile')).result)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: figs
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.2.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-11 00:00:00.000000000 Z
+date: 2014-03-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -43,6 +43,22 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: 2.0.5
+- !ruby/object:Gem::Dependency
+  name: git
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.6
 description: Simple app configuration using ENV and YAML files
 email: hab278@nyu.edu
 executables:
@@ -50,7 +66,20 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/figs/application.rb
+- lib/figs/env.rb
+- lib/figs/error.rb
+- lib/figs/figfile.rb
+- lib/figs/git_handler.rb
+- lib/figs/install.rb
+- lib/figs/tasks/install.rake
+- lib/figs/templates/application.yml
+- lib/figs/version.rb
+- lib/figs.rb
 - bin/figsify
+- Rakefile
+- Gemfile
+- README.md
 homepage: https://github.com/NYULibraries/figs
 licenses:
 - MIT
@@ -64,12 +93,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 4045786731158848396
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 4045786731158848396
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23