fini 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d439dd98e260d3baefa2aae841441819e5198346
+  data.tar.gz: 308f39f9f6630fa1e2425ada57231d7e71b33506
+SHA512:
+  metadata.gz: 9d37ba9f66fd6404daff64826db1aedbc58141f8d1c871d4da8b124be8005bf5dde1e763aa81191d5b0362f54e748d77e6b82bd7be17221f6105b891eeb7c0e8
+  data.tar.gz: 3a56a495c1d59c80483e16bd7a53023fa1e617a60c88fff05a3fe5ae493ed08448475cf5b94708f451c90d903e3d30a4290fb26b1fe68c6ca8c6bb6b798dc53a

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+lib/coverage
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.idea/

data/.yardopts

@@ -0,0 +1,2 @@
+--markup-provider=redcarpet
+--markup=markdown

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in fini.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Mikael Arvola
+
+MIT License
+
+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,128 @@
+# Fini
+
+Fini is a performance-optimized ini parser that supports strings, booleans, integers and floats.
+
+## Syntax for ini files
+
+* A section is marked with [section]
+* Key-value pairs are separated by an equals sign, eg. "key = value"
+* Quotations for strings are optional
+* Lines beginning with ; are comments
+* Literal "true" and "false" (without quotes) as the value will be converted to boolean
+* A number without a period will be converted into an integer
+* A number with one period will be converted into a float
+* Keys can be any arbitrary string as long as it doesn't contain an equals sign, and are kept as strings
+
+Sections can also have sub-sections by appending the sub-section's name to the section with a
+period, eg: [section.subsection]
+
+Subsections will be hashes in the section with the sub-section name as the key (symbol).
+
+### Sample ini content
+
+A basic ini might look like this:
+
+```ini
+[section]
+string = some text
+boolean = true
+number = 1
+
+[section.subsection]
+key = value
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'fini'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install fini
+
+## Usage
+
+The quickest way to use Fini is to invoke the module method `parse`:
+
+```ruby
+require 'fini'
+
+data = Fini.parse(ini)
+```
+
+The `data` variable will now contain an `IniObject` where each section is a method. If using the sample ini from
+above, you might access data like this:
+
+```ruby
+data.section 'string'
+# => "some text"
+
+# Array notation works as well
+data.section['string']
+# => "some text"
+```
+
+You can also supply a default value as a second argument, which is `nil` by default:
+
+```ruby
+data.section 'does not exist', 'none'
+# => "none"
+
+data.section 'does not exist'
+# => nil
+```
+
+### Subsections
+
+Fini also supports subsections. Here's an ini file with a use case:
+
+```ini
+[server.testing]
+database = foo
+user = fooman
+password = foopass
+
+[server.staging]
+database = stagefoo
+user = foomanstage
+password = foopassstage
+```
+
+Subsections are added as symbol keys to the section, and are just basic hashes from there on:
+
+```ruby
+data.server[:testing]
+# => {'database' => 'foo', 'user' => 'fooman', 'password' => 'foopass'}
+
+data.server[:testing]['database']
+# => "foo"
+```
+
+### Instance usage
+
+If an instance object is needed, Fini has `Fini::Ini` with the methods `parse` and `load`. `load` is a
+convenience method for loading an ini file instead of a string.
+
+```ruby
+require 'fini'
+
+parser = Fini::Ini.new
+data = parser.parse(ini)
+
+data2 = parser.load('path/to/ini.ini')
+```
+
+## Planned features
+
+* An option to convert all keys to symbols
+* Support for escape characters in quoted strings
+* Support for symbol values
+
+## License
+[MIT license](http://www.opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/fini.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'fini/version'
+
+Gem::Specification.new do |gem|
+    gem.name          = "fini"
+    gem.version       = Fini::VERSION
+    gem.authors       = ["Mikael Arvola"]
+    gem.email         = ["mikael@arvola.com"]
+    gem.description   = %q{Fini is an ini-parser optimized for performance.}
+    gem.summary       = %q{Fast ini parser}
+    gem.homepage      = "https://github.com/arvola/fini"
+
+    gem.files         = `git ls-files`.split($/)
+    gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
+    gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+    gem.require_paths = ["lib"]
+    gem.has_rdoc      = 'yard'
+
+    gem.add_development_dependency "rspec"
+    gem.add_development_dependency "simplecov"
+end

data/lib/fini.rb

@@ -0,0 +1,132 @@
+require_relative "fini/version"
+
+module Fini
+
+    # Instance class for accessing Fini functionality
+    #
+    class Ini
+        def parse content
+            Fini.parse content
+        end
+        def load file
+            Fini.parse File.read(file)
+        end
+    end
+
+    NUMBER_REGEX = /\A[+-]?[\d]+\.?\d*\Z/
+
+    def self.is_number? string
+        # Regex has the best performance overall, and it doesn't take longer with
+        # long strings that are not numbers. In other words, getting a false is very fast,
+        # and getting a true is only slightly slower than using Float()
+        if NUMBER_REGEX === string
+            true
+        else
+            false
+        end
+    end
+
+    # A static method for parsing a string with ini content.
+    #
+    # @param [String] content       Ini text to parse
+    # @return [Fini::IniObject]     Parsed values
+    def self.parse content
+        source = content
+        data = IniObject.new
+        section = nil
+        source.lines do |line|
+            line.strip!
+            case line[0]
+                when '['
+                    key = line.delete "[]"
+                    section = data.get_section key
+                when ';'
+                    next
+                else
+                    next if section.nil?
+                    pos = line.index '='
+                    unless pos.nil?
+                        key = line[0, pos]
+                        val = line[(pos + 1)..-1]
+                        unless key.nil? || val.nil?
+                            key.strip!
+                            val.strip!
+                            if Fini.is_number? val
+                                if val.include?('.')
+                                    section[key] = Float(val)
+                                else
+                                    section[key] = Integer(val)
+                                end
+                            elsif (val[0] == '"' && val[-1] == '"') or (val[0] == "'" && val[-1] == "'")
+                                section[key] = val.chop.reverse.chop.reverse
+                            elsif val == "true"
+                                section[key] = true
+                            elsif val == "false"
+                                section[key] = false
+                            else
+                                section[key] = val
+                            end
+                        end
+                    end
+            end
+        end
+        @data = data
+    end
+
+    # An object that holds the data from the parsed ini-file. Sections are
+    # accessed as methods, which returns a hash.
+    class IniObject
+        def initialize
+            @data = {}
+        end
+
+        # @param [String] key
+        # @return [Hash]
+        def get_section key
+            if key.include? '.'
+                sections = key.split('.')
+                obj = do_get_section sections.shift
+
+                sections.each do |key|
+                    key = key.to_sym
+                    if obj.has_key? key
+                        obj = obj[key]
+                    else
+                        obj = obj[key] = {}
+                    end
+                end
+                obj
+            else
+                do_get_section key
+            end
+        end
+
+        protected
+
+        # @param [String] key
+        # @return [Hash]
+        def do_get_section key
+            key = key.to_sym
+            if @data.has_key? key
+                @data[key]
+            else
+                create_section key
+            end
+        end
+
+        # @param [Symbol] key
+        # @return [Hash]
+        def create_section key
+            data = @data[key] = {}
+            method = Proc.new do |k = nil, default = nil|
+                if k.nil?
+                    data
+                else
+                    data.has_key?(k) ? data[k] : default
+                end
+            end
+            define_singleton_method(key, method)
+            data
+        end
+    end
+end

data/lib/fini/version.rb

@@ -0,0 +1,3 @@
+module Fini
+  VERSION = "1.0.0"
+end

data/spec/fini_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe Fini do
+    let(:data) do
+        content = %q{
+            [section]
+            string = string
+            boolean = true
+            number = 1
+            float = 1.1
+            ;[commented]
+            ;foo = foo}
+        Fini.parse content
+    end
+    let (:subsection) do
+        content = %q{
+            [section]
+            string = string
+
+            [section.subsection]
+            key = value
+
+            [section2.subsection]
+            name = content}
+        Fini.parse content
+    end
+
+    describe "::is_number?" do
+        it "detects numbers correctly" do
+            expect(Fini.is_number?("100")).to be_true
+            expect(Fini.is_number?("100.1")).to be_true
+            expect(Fini.is_number?("0.9876543210")).to be_true
+        end
+
+        it "rejects non-numbers" do
+            expect(Fini.is_number?("1000000000-")).to be_false
+            expect(Fini.is_number?("a.123")).to be_false
+            expect(Fini.is_number?("123.123.123")).to be_false
+        end
+    end
+
+    describe Fini::IniObject do
+        it "has a section method" do
+            expect(data).to respond_to(:section)
+        end
+    end
+
+    describe "::parse" do
+        it "parses a string" do
+            expect(data.section).to include('string' => 'string')
+        end
+
+        it "parses a boolean" do
+            expect(data.section).to include('boolean' => true)
+        end
+
+        it "parses numbers" do
+            expect(data.section).to include('number' => 1)
+            expect(data.section).to include('float' => 1.1)
+        end
+
+        it "ignores comments" do
+            expect{data.commented}.to raise_error(NoMethodError)
+        end
+
+        it "parses subsections" do
+            expect(subsection.section[:subsection]).to include('key' => 'value')
+        end
+
+        it "creates sections automatically with subsections" do
+            expect(subsection.section2[:subsection]).to include('name' => 'content')
+        end
+    end
+end

data/spec/ini/file.ini

@@ -0,0 +1,20 @@
+[section]
+string = string
+boolean = true
+number = 1
+
+[section.subsection]
+key = value
+
+[new.sub]
+name = content
+
+[server.testing]
+database = foo
+user = fooman
+password = foopass
+
+[server.staging]
+database = stagefoo
+user = foomanstage
+password = foopassstage

data/spec/ini_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Fini::Ini do
+    let (:parser) { Fini::Ini.new }
+
+    it "loads and parses files" do
+        data = parser.load(File.dirname(__FILE__) + '/ini/file.ini')
+        expect(data.section).to include('string' => 'string')
+    end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require_relative '../lib/fini'

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: fini
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Mikael Arvola
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Fini is an ini-parser optimized for performance.
+email:
+- mikael@arvola.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .yardopts
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- fini.gemspec
+- lib/fini.rb
+- lib/fini/version.rb
+- spec/fini_spec.rb
+- spec/ini/file.ini
+- spec/ini_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/arvola/fini
+licenses: []
+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.0.2
+signing_key: 
+specification_version: 4
+summary: Fast ini parser
+test_files:
+- spec/fini_spec.rb
+- spec/ini/file.ini
+- spec/ini_spec.rb
+- spec/spec_helper.rb