app_config 0.2.3 → 0.2.4

data/README

@@ -0,0 +1,48 @@
+= AppConfig
+
+An easy to use, customizable library to easily store and retrieve application
+(or library) configuration, API keys or basically anything in 'key/value' pairs.
+
+
+== Usage
+
+Usage is simple.  Just pass either a hash of options, or a block, to
+AppConfig.setup.  See AppConfig::Base for a list of valid storage methods.
+
+For example, given this YAML file:
+
+  ---
+  admin_email: 'admin@example.com'
+  api_name:    'Supr Webz 2.0'
+  api_key:     'SUPERAWESOMESERVICE'
+
+Use it like so:
+
+  require 'app_config'
+
+  AppConfig.setup do |config|
+    config[:storage_method] = :yaml
+    config[:path] = '/path/to/app_config.yml'
+  end
+
+  # Later on...
+  # Strings or symbols as keys.
+  AppConfig['admin_email'] # => 'admin@example.com'
+  AppConfig[:api_name]     # => 'Supr Webz 2.0'
+  AppConfig[:api_key]      # => 'SUPERAWESOMESERVICE'
+
+Want SQLite3?  No problem!
+
+  AppConfig.setup do |config|
+    config[:storage_method] = :sqlite
+    config[:database] = '/path/to/database.sqlite3'
+    config[:table] = 'app_config'
+  end
+
+  AppConfig[:column]  # => 'value'
+
+You can also pass a <tt>:uri</tt> option, which will automatically determine
+the options for the storage method.  So in the block (or passed in hash):
+
+  config[:uri] = 'sqlite://path/to/database.sqlite3'
+  config[:uri] = 'yaml://path/to/app_config.yml'

data/Rakefile

@@ -0,0 +1,10 @@
+require 'spec/rake/spectask'
+
+FileList[File.dirname(__FILE__) + '/tasks/**/*.rake'].each { |task| load task }
+
+task :default => [:spec]
+
+desc 'Start an irb session with AppConfig loaded'
+task :console do
+  sh "irb -I ./lib -r 'app_config'"
+end

data/lib/app_config/base.rb

@@ -0,0 +1,61 @@
+module AppConfig
+
+  # The Base storage class.
+  # Acts as a wrapper for the different storage methods.
+  #
+  # See each storage method's documentation for their specific options.
+  #
+  # Valid storage methods:
+  # * :sqlite (AppConfig::Storage::Sqlite)
+  # * :yaml (AppConfig::Storage::YAML)
+  class Base
+
+    # TODO: Change the default storage method to not use YAML.
+    DEFAULTS = {
+      :storage_method => :yaml,
+    }
+
+    # Accepts either a hash of +options+ or a block (which overrides
+    # any options passed in the hash).
+    def initialize(options = {}, &block)
+      @options = DEFAULTS.merge(options)
+      yield @options if block_given?
+      determine_storage_method if @options[:uri]
+      @storage = initialize_storage
+    end
+
+    # Access the <tt>key</tt>'s value in @storage.
+    def [](key)
+      @storage[key]
+    end
+
+  private
+
+  # Sets the storage_method depending on the URI given.
+  def determine_storage_method
+    uri = URI.parse(@options.delete(:uri))
+    case uri.scheme
+    when 'sqlite'
+      @options[:storage_method] = :sqlite
+      @options[:database] = uri.path
+    when 'yaml'
+      @options[:storage_method] = :yaml
+      @options[:path] = uri.path
+    end
+  end
+
+  # This decides how to load the data, based on the +storage_method+.
+  # TODO: Maybe purge AppConfig options (ie, those not related to the user-end).
+  def initialize_storage
+    case @options[:storage_method]
+    when :sqlite
+      AppConfig::Storage::Sqlite.load(@options)
+    when :yaml
+      AppConfig::Storage::YAML.load(@options)
+    else
+      raise UnknownStorageMethod
+    end
+  end
+
+  end # Base
+end # AppConfig

data/lib/app_config/storage/sqlite.rb

@@ -0,0 +1,59 @@
+module AppConfig
+  module Storage
+
+    # SQLite3 storage method.
+    class Sqlite
+      attr_accessor :data
+
+      DEFAULTS = {
+        :database => File.expand_path(File.join(ENV['HOME'], '.app_config.sqlite3')),
+        :table => 'app_config'
+      }
+
+      # Loads @data with the SQLite3 database located at +path+.
+      # @data will be the Hashish that is accessed like AppConfig[:key].
+      #
+      # Defaults to $HOME/.app_config.sqlite3
+      def initialize(options)
+        @options = DEFAULTS.merge(options)
+        @db = SQLite3::Database.open(@options[:database])
+        @data = load_from_database
+      end
+
+      # Creates a new Sqlite storage with the given +path+ and returns the data.
+      def self.load(path)
+        new(path).data
+      end
+
+      private
+
+      # Returns a Hashish that looks something like {:column => value}.
+      # TODO: This could use a bit of work.
+      def load_from_database
+        query = ["SELECT * FROM sqlite_master",
+                 "WHERE type == 'table' AND name == '#{@options[:table]}'",
+                 "AND name != 'sqlite_sequence'"].join(' ')
+        table = @db.get_first_row(query).last
+        values(columns(table))
+      end
+
+      def values(columns)
+        data = Hashish.new
+        query = "SELECT #{columns.join(', ')} FROM #{@options[:table]}"
+        @db.get_first_row(query).each_with_index do |value, index|
+          data[columns[index]] = value
+        end
+        data
+      end
+
+      def columns(table)
+        columns = table.split(', ')
+        # Trip the first element, since it's the SQL CREATE statement.
+        columns = columns[1, columns.size]
+        # Yes, Ruby is 'elegant', but this is fucking disgusting.  There *must* be a better way.
+        columns.map! {|c| c.split('"').reject {|e| e.empty? }.reject {|e| e.include? '('}}.flatten!
+      end
+
+    end # Sqlite
+  end # Storage
+end # AppConfig

data/lib/app_config/storage/yaml.rb

@@ -0,0 +1,29 @@
+module AppConfig
+  module Storage
+
+    # YAML storage method.
+    class YAML
+      attr_reader :data
+
+      DEFAULTS = {
+        :path => File.expand_path(File.join(ENV['HOME'], '.app_config.yml'))
+      }
+
+      # Loads @data with the YAML file located at +path+.
+      # @data will be the Hashish that is accessed with AppConfig[:key].
+      #
+      # Defaults to $HOME/.app_config.yml
+      def initialize(options)
+        path = options[:path] || DEFAULTS[:path]
+        # Make sure to use the top-level YAML module here.
+        @data = Hashish.new(::YAML.load_file(path))
+      end
+
+      # Creates a new YAML storage with the given +path+ and returns the data.
+      def self.load(path)
+        new(path).data
+      end
+
+    end # YAML
+  end # Storage
+end # AppConfig

data/lib/app_config/storage.rb

@@ -0,0 +1,6 @@
+module AppConfig
+  module Storage
+    autoload :Sqlite, 'app_config/storage/sqlite'
+    autoload :YAML, 'app_config/storage/yaml'
+  end
+end

data/lib/app_config.rb

@@ -0,0 +1,44 @@
+$LOAD_PATH.unshift File.dirname(__FILE__)
+
+# TODO: Only load deps if needed (no gems unless required).
+libs = %w{ sqlite3 yaml uri }
+
+begin
+  libs.each { |lib| require lib }
+rescue LoadError
+  require 'rubygems'
+  libs.each { |lib| require lib }
+end
+
+require 'core_ext/hashish'
+
+# TODO: Move these to their own file.
+class NotConfigured < Exception
+  def to_s; "Must call 'AppConfig.setup' to setup storage!"; end
+end
+class UnknownStorageMethod < Exception; end
+
+module AppConfig
+  VERSION = '0.2.4'
+
+  autoload :Base, 'app_config/base'
+  autoload :Storage, 'app_config/storage'
+
+  # Returns the AppConfig version string.
+  def self.to_version
+    "#{self.class} v#{VERSION}"
+  end
+
+  # Access the configured <tt>key</tt>'s value.
+  def self.[](key)
+    raise NotConfigured unless defined?(@@storage)
+    @@storage[key]
+  end
+
+  # Accepts an +options+ hash or a block.
+  # See AppConfig::Base for valid storage methods.
+  def self.setup(options = {}, &block)
+    @@storage = AppConfig::Base.new(options, &block)
+  end
+
+end # AppConfig

data/lib/core_ext/hashish.rb

@@ -0,0 +1,137 @@
+# Stolen from Rails Active Support and aliased to Hashish.
+#
+# This class has dubious semantics and we only have it so that
+# people can write params[:key] instead of params['key']
+# and they get the same value for both keys.
+class HashWithIndifferentAccess < Hash
+  def initialize(constructor = {})
+    if constructor.is_a?(Hash)
+      super()
+      update(constructor)
+    else
+      super(constructor)
+    end
+  end
+
+  def default(key = nil)
+    if key.is_a?(Symbol) && include?(key = key.to_s)
+      self[key]
+    else
+      super
+    end
+  end
+
+  alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+  alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+  # Assigns a new value to the hash:
+  #
+  #   hash = HashWithIndifferentAccess.new
+  #   hash[:key] = "value"
+  #
+  def []=(key, value)
+    regular_writer(convert_key(key), convert_value(value))
+  end
+
+  # Updates the instantized hash with values from the second:
+  #
+  #   hash_1 = HashWithIndifferentAccess.new
+  #   hash_1[:key] = "value"
+  #
+  #   hash_2 = HashWithIndifferentAccess.new
+  #   hash_2[:key] = "New Value!"
+  #
+  #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
+  #
+  def update(other_hash)
+    other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+    self
+  end
+
+  alias_method :merge!, :update
+
+  # Checks the hash for a key matching the argument passed in:
+  #
+  #   hash = HashWithIndifferentAccess.new
+  #   hash["key"] = "value"
+  #   hash.key? :key  # => true
+  #   hash.key? "key" # => true
+  #
+  def key?(key)
+    super(convert_key(key))
+  end
+
+  alias_method :include?, :key?
+  alias_method :has_key?, :key?
+  alias_method :member?, :key?
+
+  # Fetches the value for the specified key, same as doing hash[key]
+  def fetch(key, *extras)
+    super(convert_key(key), *extras)
+  end
+
+  # Returns an array of the values at the specified indices:
+  #
+  #   hash = HashWithIndifferentAccess.new
+  #   hash[:a] = "x"
+  #   hash[:b] = "y"
+  #   hash.values_at("a", "b") # => ["x", "y"]
+  #
+  def values_at(*indices)
+    indices.collect {|key| self[convert_key(key)]}
+  end
+
+  # Returns an exact copy of the hash.
+  def dup
+    HashWithIndifferentAccess.new(self)
+  end
+
+  # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash
+  # Does not overwrite the existing hash.
+  def merge(hash)
+    self.dup.update(hash)
+  end
+
+  # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
+  # This overloaded definition prevents returning a regular hash, if reverse_merge is called on a HashWithDifferentAccess.
+  def reverse_merge(other_hash)
+    super other_hash.with_indifferent_access
+  end
+
+  def reverse_merge!(other_hash)
+    replace(reverse_merge( other_hash ))
+  end
+
+  # Removes a specified key from the hash.
+  def delete(key)
+    super(convert_key(key))
+  end
+
+  def stringify_keys!; self end
+  def symbolize_keys!; self end
+  def to_options!; self end
+
+  # Convert to a Hash with String keys.
+  def to_hash
+    Hash.new(default).merge!(self)
+  end
+
+  protected
+    def convert_key(key)
+      key.kind_of?(Symbol) ? key.to_s : key
+    end
+
+    def convert_value(value)
+      case value
+      when Hash
+        value.with_indifferent_access
+      when Array
+        value.collect { |e| e.is_a?(Hash) ? e.with_indifferent_access : e }
+      else
+        value
+      end
+    end
+end
+
+# Simple alias.
+Hashish = HashWithIndifferentAccess

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: app_config
 version: !ruby/object:Gem::Version 
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors: 
 - Dale Campbell
@@ -11,8 +11,17 @@ cert_chain: []
 
 date: 2009-09-27 00:00:00 -05:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sqlite3-ruby
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
 description: An easy to use, customizable library to easily store and retrieve application configuration.
 email: 
 - oshuma@gmail.com
@@ -22,15 +31,23 @@ extensions: []
 
 extra_rdoc_files: []
 
-files: []
-
+files: 
+- Rakefile
+- README
+- lib/app_config.rb
+- lib/app_config/base.rb
+- lib/app_config/storage.rb
+- lib/app_config/storage/sqlite.rb
+- lib/app_config/storage/yaml.rb
+- lib/core_ext/hashish.rb
 has_rdoc: true
 homepage: http://oshuma.github.com/app_config
 licenses: []
 
 post_install_message: 
-rdoc_options: []
-
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement