figtree 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1233d1fd9829365dc29dc2ed44b73634c7c4cfa6
+  data.tar.gz: 44fba04a7b4c08a88f1c4d20e0464d0d25643ab8
+SHA512:
+  metadata.gz: f0ff4a80575eeea798dfe2a2adeee750f614428d866f160a3bb4f7cae001f797e9aedf671496102b18b67738f2f29e4464d2ee02d4a6882759ec852b30355c13
+  data.tar.gz: d5c9d8a28065b65c74a976a47e5a67215418fa8ba8437a289db1f83a12b08355c9ca7f00596cf29709873af0c31537c049dba6d97fa2526443545c38bf36a5d6

data/.gitignore

@@ -0,0 +1,38 @@
+.DS_STORE
+
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.2.2

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/Gemfile.lock

@@ -0,0 +1,36 @@
+PATH
+  remote: .
+  specs:
+    figtree (0.0.1)
+      parslet
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    blankslate (3.1.3)
+    diff-lcs (1.2.5)
+    parslet (1.7.1)
+      blankslate (>= 2.0, <= 4.0)
+    rspec (3.3.0)
+      rspec-core (~> 3.3.0)
+      rspec-expectations (~> 3.3.0)
+      rspec-mocks (~> 3.3.0)
+    rspec-core (3.3.2)
+      rspec-support (~> 3.3.0)
+    rspec-expectations (3.3.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-mocks (3.3.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-support (3.3.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  figtree!
+  rspec (>= 3.0.0)
+
+BUNDLED WITH
+   1.10.6

data/README.md

@@ -0,0 +1,28 @@
+# Figtree
+## about
+A parser and transformer for loading `.ini` files into Ruby dot notation accessible objects. `.ini` is not a standardized format. But the parser and transformer are easy to extend, unlike regex. :)
+
+## performance
+A typical `.ini` file takes slightly less than 0.02s to be parsed, transformed, and loaded.
+
+## installation
+`gem install figtree`
+
+## usage
+    require 'figtree'
+    config = Figtree.load_config('spec/support/settings.conf')
+    config.common.basic_size_limit
+    => 26214400
+
+# development
+## installation
+`bundle install`
+
+## tests
+`rspec spec/`
+
+### TODO
+- refactor marked TODO listings in files (mostly refactoring to generic)
+- allow indifferent access? (not just dot notation but allow hash access)
+- add more unit test coverage to Transformer
+- seems like Parslet doesn't have a `TransformFailed` error format, worth adding one?

data/figtree.gemspec

@@ -0,0 +1,23 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "figtree/version"
+
+Gem::Specification.new do |gem|
+  gem.name    = 'figtree'
+  gem.version = Figtree::VERSION
+  gem.date    = Date.today.to_s
+
+  gem.summary = "A parser and transformer for loading `.ini` files into Ruby dot notation accessible objects."
+  gem.description = "See README.md"
+
+  gem.authors  = ['Alex Moore-Niemi']
+  gem.email    = 'moore.niemi@gmail.com'
+  gem.homepage = 'https://github.com/mooreniemi/figtree'
+
+  gem.add_runtime_dependency 'parslet', '~> 1.7'
+  gem.add_development_dependency 'rspec', '~> 3.0', '>= 3.0.0'
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.require_paths = ["lib"]
+end

data/lib/figtree.rb

@@ -0,0 +1,30 @@
+require 'figtree/parser'
+require 'figtree/transformer'
+require 'figtree/ini_config'
+
+module Figtree
+  def self.load_config(file_path, overrides=[])
+    IniConfig.new(
+      figgy_transform(
+        figgy_parse(
+          File.read(file_path)
+        ),
+        overrides
+      )
+    )
+  end
+
+  private
+  def self.figgy_parse(str)
+    Parser.new.parse(str)
+  rescue Parslet::ParseFailed => failure
+    puts failure.cause.ascii_tree
+  end
+
+  def self.figgy_transform(tree, overrides = [])
+    Transformer.new(overrides).apply(tree)
+  rescue
+    puts 'failed transform'
+    {} # returning hash just to preserve stack trace
+  end
+end

data/lib/figtree/ini_config.rb

@@ -0,0 +1,10 @@
+require 'ostruct'
+module Figtree
+  class IniConfig < OpenStruct
+    def initialize(array = [])
+      # TODO move the reduction to #load_config
+      # TODO then this class can be a shell
+      super(array.reduce({}, :merge))
+    end
+  end
+end

data/lib/figtree/parser.rb

@@ -0,0 +1,91 @@
+require 'parslet'
+
+module Figtree
+  # ConFIG into a Tree :)
+  class Parser < Parslet::Parser
+    rule(:eof) { any.absent? }
+    rule(:group_title) { match('[a-zA-Z]').repeat(1) }
+    rule(:newline)  { match("\\n").repeat(1) >> match("\\r").maybe }
+    rule(:space) { match('\s').repeat(0) }
+    rule(:grouper) do
+      str('[') >>
+      group_title.as(:group_title) >>
+      str(']')
+    end
+
+    rule(:comment) do
+      str(';') >>
+      (newline.absent? >> any).repeat
+    end
+
+    rule(:string) do
+      str('"') >>
+      ((str('\\') >> any) | (str('"').absent? >> any)).repeat.as(:string) >>
+      str('"')
+    end
+
+    rule(:boolean) do
+      (str('no') | str('yes')).as(:boolean)
+    end
+
+    rule(:number) do
+      match('[0-9]').repeat(1).as(:number)
+    end
+
+    rule(:array) do
+      (match('[a-zA-Z]').repeat(1) >>
+       (str(',') >>
+        match('[a-zA-Z]').repeat(1)).repeat.maybe).maybe.as(:array) >>
+      (str(',') | newline | eof)
+    end
+
+    rule(:file_path) do
+      match('[/a-z/]').repeat(1).as(:file_path)
+    end
+
+    rule(:snake_case_key) do
+      match('[a-zA-Z0-9_]').repeat(1).as(:snake_case_key)
+    end
+
+    rule(:snakey_option_key) do
+      snake_case_key.as(:key_to_be_overridden) >>
+      str('<') >>
+      snake_case_key.as(:optional_key) >>
+      str('>')
+    end
+
+    rule(:assignment) do
+      snake_case_key >>
+      space >>
+      str("=") >>
+      space >>
+      (number | boolean | array | snake_case_key | file_path | string)
+    end
+
+    rule(:override_assignment) do
+      snakey_option_key >>
+      space >>
+      str("=") >>
+      space >>
+      file_path
+    end
+
+    rule(:assignment_or_comment) do
+      ( comment | assignment | override_assignment )
+    end
+
+    rule(:group_member) do
+      newline.maybe >>
+      assignment_or_comment >>
+      newline.maybe
+    end
+
+    rule(:group) do
+      (grouper >>
+       group_member.repeat.maybe).as(:group).
+      repeat.maybe
+    end
+
+    root(:group)
+  end
+end

data/lib/figtree/transformer.rb

@@ -0,0 +1,64 @@
+require 'parslet'
+require 'ostruct'
+
+module Figtree
+  # once you have an AST, you can do type transformations
+  class Transformer < Parslet::Transform
+    attr_accessor :overrides
+
+    def initialize(overrides = [], &block)
+      @overrides = overrides
+      super(&block)
+    end
+
+    # TODO these could largely be consolidated with some rearrangement
+    # TODO subtree is considered too flexible, switch to simple(:x)?
+    rule(:snake_case_key => simple(:key), :number => subtree(:value)) do
+      {
+        key.to_sym => Integer(value)
+      }
+    end
+    rule(:snake_case_key => simple(:key), :array => subtree(:value)) do
+      {
+        key.to_sym => Array(value)
+      }
+    end
+    rule(:snake_case_key => simple(:key), :string => subtree(:value)) do
+      {
+        key.to_sym => String(value)
+      }
+    end
+    rule(:snake_case_key => simple(:key), :boolean => simple(:value)) do
+      {
+        # Boolean(value) fails
+        key.to_sym => String(value)
+      }
+    end
+    rule(:snake_case_key => simple(:key), :file_path => subtree(:value)) do
+      {
+        key.to_sym => String(value)
+      }
+    end
+    rule(
+      :key_to_be_overridden => subtree(:a),
+      :optional_key => subtree(:b),
+      :file_path => subtree(:c)
+    ) do
+      if !@overrides.nil? && @overrides.include?(b[:snake_case_key])
+        {
+          a[:snake_case_key] => String(c)
+        }
+      else
+        {
+        }
+      end
+    end
+    rule(:group => subtree(:group_members)) do
+      group_title = group_members[0][:group_title].to_sym
+      group_values = OpenStruct.new(group_members[1..-1].reduce({}, :merge))
+      {
+        group_title => group_values
+      }
+    end
+  end
+end

data/lib/figtree/version.rb

@@ -0,0 +1,3 @@
+module Figtree
+  VERSION = "0.0.1"
+end

data/spec/figtree/parser_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+module Figtree
+  describe Parser do
+    let(:parser) { Parser.new }
+    it 'can parse newlines' do
+      expect(parser.newline).to parse("\n")
+    end
+    it 'can parse group names' do
+      expect(parser.grouper).to parse('[common]')
+    end
+    it 'can parse comments' do
+      expect(parser.comment).to parse('; This is a comment\n')
+    end
+    it 'can parse snake_case keys' do
+      expect(parser.snake_case_key).to parse('basic_size_limit')
+    end
+    it 'can parse strings' do
+      expect(parser.string).to parse('"hello there, ftp uploading"')
+    end
+    it 'can parse arrays' do
+      expect(parser.array).to parse("a,")
+      expect(parser.array).to parse("a,b")
+      expect(parser.array).to parse("a,b,c\n")
+      expect(parser.array).to_not parse(',,')
+      expect(parser.array).to parse("array,of,values\n")
+      expect(parser.array).to parse("array,of,values")
+    end
+    it 'can parse numbers' do
+      expect(parser.number).to parse("26214400")
+    end
+    it 'can parse booleans flexibly' do
+      expect(parser.boolean).to parse("no")
+      expect(parser.boolean).to parse("yes")
+    end
+    it 'can parse assignments' do
+      expect(parser.assignment).to parse('basic_size_limit = 26214400')
+      expect(parser.assignment).to parse('path = /srv/var/tmp/')
+      expect(parser.assignment).to_not parse('path<itscript> = /srv/tmp/')
+      expect(parser.assignment).to parse('name = "hello there, ftp uploading"')
+      expect(parser.assignment).to parse('params = array,of,values')
+    end
+    it 'can parse keys with optional overrides' do
+      expect(parser.snakey_option_key).to parse('path<itscript>')
+    end
+    it 'can parse file_paths' do
+      expect(parser.file_path).to parse('/srv/tmp/')
+    end
+    it 'can parse overrides' do
+      expect(parser.override_assignment).to parse('path<itscript> = /srv/tmp/')
+    end
+
+    describe "using the settings.conf file for input" do
+      let(:settings_path) { 'spec/support/settings.conf' }
+      let(:multi_group) {
+        [
+          "[common]",
+          "basic_size_limit = 234234",
+          "[rare]",
+          "pepes = 0"
+        ].join("\n") + "\n"
+      }
+
+      it 'parses a group member' do
+        expect(parser.group_member).to parse("\nbasic_size_limit = 26214400\n")
+      end
+      it 'can parse single assignment inside a group' do
+        expect(parser.group).
+          to parse("[common]\nbasic_size_limit = 26214400\n")
+      end
+      it 'can parse multiple assignments inside a group' do
+        expect(parser.group).
+          to parse("[common]\nbasic_size_limit = 26214400\nstudent_size_limit = 52428800\n")
+      end
+      it 'can parse multiple groups' do
+        expect(parser.group).to parse(multi_group)
+      end
+
+    end
+  end
+end

data/spec/figtree/transformer_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+module Figtree
+  describe Transformer do
+    let(:tree) do
+      Parser.new.parse("[common]\nbasic_size_limit = 26214400\n")
+    end
+    it 'can apply an int type conversion' do
+      expect(Transformer.new.apply(tree)).to eq(
+        [
+          {
+            common: OpenStruct.new({basic_size_limit: 26214400})
+          }
+        ]
+      )
+    end
+  end
+end

data/spec/figtree_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+# for the performance test at bottom
+require 'benchmark'
+
+describe Figtree do
+  describe '#load_config' do
+    let(:settings_path) { 'spec/support/settings.conf' }
+    let(:common) do
+      OpenStruct.new(
+        :basic_size_limit => 26214400,
+        :student_size_limit => 52428800,
+        :paid_users_size_limit => 2147483648,
+        :path => "/srv/var/tmp/",
+      )
+    end
+
+    let(:common_with_override) do
+      OpenStruct.new(
+        :basic_size_limit => 26214400,
+        :student_size_limit => 52428800,
+        :paid_users_size_limit => 2147483648,
+        :path => "/srv/var/tmp/",
+      )
+    end
+
+    let(:the_whole_kebab) do
+      Figtree::IniConfig.new(
+        [
+          {
+            common: OpenStruct.new(
+              {
+                :basic_size_limit => 26214400,
+                :student_size_limit=> 52428800,
+                :paid_users_size_limit=> 2147483648,
+                :path=> "/srv/var/tmp/"
+              }
+            )
+          },
+          {
+            ftp: OpenStruct.new(
+              {
+                :name => "hello there, ftp uploading",
+                :path => "/tmp/",
+                :enabled => "no"
+              }
+            )
+          },
+          {
+            http: OpenStruct.new(
+              {
+                :name => "http uploading",
+                :path => "/tmp/",
+                :params => ["array,of,values"]
+              }
+            )
+          }
+        ]
+      )
+    end
+
+    it 'can parse a group and provide dot notation access' do
+      expect(Figtree.load_config(settings_path).common).to eq(common)
+    end
+    it 'can parse the overrides correctly' do
+      expect(Figtree.load_config(settings_path, [:itscript]).common).
+        to eq(common_with_override)
+    end
+    it 'can parse the whole Kebab without any misunderstandings' do
+      expect(Figtree.load_config(settings_path)).to eq(the_whole_kebab)
+    end
+
+    it 'can parse the whole ini file quickly' do
+      expect(
+        Benchmark.realtime do
+          Figtree.load_config(settings_path)
+        end
+      ).to be < 0.02
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require 'bundler/setup'
+Bundler.setup
+
+require 'ostruct'
+require 'parslet'
+require 'parslet/rig/rspec'
+
+Dir[File.join(File.dirname(__FILE__), "..", "lib" , "**.rb")].each do |file|
+  require file
+end
+
+RSpec.configure do |config|
+end

data/spec/support/settings.conf

@@ -0,0 +1,21 @@
+[common]
+basic_size_limit = 26214400
+student_size_limit = 52428800
+paid_users_size_limit = 2147483648
+path = /srv/var/tmp/
+path<itscript> = /srv/tmp/
+[ftp]
+name = "hello there, ftp uploading"
+path = /tmp/
+path<production> = /srv/var/tmp/
+path<staging> = /srv/uploads/
+path<ubuntu> = /etc/var/uploads
+enabled = no
+; This is a comment
+[http]
+name = "http uploading"
+path = /tmp/
+path<production> = /srv/var/tmp/
+path<staging> = /srv/uploads/; This is another comment
+params = array,of,values
+

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: figtree
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Alex Moore-Niemi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+description: See README.md
+email: moore.niemi@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-version"
+- Gemfile
+- Gemfile.lock
+- README.md
+- figtree.gemspec
+- lib/figtree.rb
+- lib/figtree/ini_config.rb
+- lib/figtree/parser.rb
+- lib/figtree/transformer.rb
+- lib/figtree/version.rb
+- spec/figtree/parser_spec.rb
+- spec/figtree/transformer_spec.rb
+- spec/figtree_spec.rb
+- spec/spec_helper.rb
+- spec/support/settings.conf
+homepage: https://github.com/mooreniemi/figtree
+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.4.6
+signing_key: 
+specification_version: 4
+summary: A parser and transformer for loading `.ini` files into Ruby dot notation
+  accessible objects.
+test_files:
+- spec/figtree/parser_spec.rb
+- spec/figtree/transformer_spec.rb
+- spec/figtree_spec.rb
+- spec/spec_helper.rb
+- spec/support/settings.conf
+has_rdoc: