xbrlware-extras 1.1.2.19

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gem "xbrlware-ruby19", :git => "git://github.com/jimlindstrom/xbrlware-ruby19.git"
+
+# Specify your gem's dependencies in xbrlware-extras.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Jim Lindstrom
+
+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,3 @@
+# xbrlware-extras
+
+This gem offers a light layer of helpers and nice-to-have functionality on top of <https://github.com/jimlindstrom/xbrlware-ruby19>

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/xbrlware-extras/context.rb

@@ -0,0 +1,66 @@
+module Xbrlware
+
+  class Context
+    def write_constructor(file, context_name)
+      period_str = "nil"
+      case
+        when !@period
+        when self.period.is_instant?
+          period_str = "Date.parse(\"#{self.period.value}\")"
+        when self.period.is_duration?
+          period_str = "{"
+          period_str += "\"start_date\" => Date.parse(\"#{self.period.value["start_date"].to_s}\"),"
+          period_str +=   "\"end_date\" => Date.parse(\"#{self.period.value[  "end_date"].to_s}\")"
+          period_str += "}"
+      end
+
+      entity_str = "nil"
+      case
+        when !@entity || !@entity.segment
+        else
+          identifier_str = "\"#{@entity.identifier}\""
+          segment_str = "{}"
+          entity_str = "Xbrlware::Entity.new(identifier=#{identifier_str}, segment=#{segment_str})"
+      end
+
+      file.puts "#{context_name} = Xbrlware::Factory.Context(:period => #{period_str}, :entity => #{entity_str})"
+    end
+
+    class Period
+      def days
+        Xbrlware::DateUtil.days_between(@value["end_date"], @value["start_date"])
+      end
+
+      def plus_n_months(n)
+        case
+          when is_instant?
+            new_value = @value.dup
+            n.times do
+              new_value = new_value.next_month
+            end
+            return Period.new(new_value)
+          when is_duration?
+            new_value = {"start_date"=>@value["start_date"].dup, "end_date"=>@value["end_date"].dup}
+            n.times do
+              new_value["start_date"] = new_value["start_date"].next_month
+              new_value[  "end_date"] = new_value[  "end_date"].next_month
+            end
+            return Period.new(new_value)
+        end
+        raise RuntimeError.new("not supported")
+      end
+
+      def to_pretty_s
+        case
+          when is_instant?
+            return "#{@value}" 
+          when is_duration?
+            return "#{@value["start_date"]} to #{@value["end_date"]}" 
+          else
+            return to_s
+        end
+      end
+    end
+  end
+
+end

data/lib/xbrlware-extras/dateutil.rb

@@ -0,0 +1,16 @@
+module Xbrlware
+
+  module DateUtil
+    def self.days_between(date1=Date.today, date2=Date.today)
+      begin
+        date1=Date.parse(date1) if date1.is_a?(String)
+        date2=Date.parse(date2) if date2.is_a?(String)
+        (date1 > date2) ? (recent_date, past_date = date1, date2) : (recent_date, past_date = date2, date1)
+        (recent_date - past_date).round
+      rescue Exception => e
+        0
+      end
+    end
+  end
+
+end

data/lib/xbrlware-extras/factory.rb

@@ -0,0 +1,62 @@
+module Xbrlware
+  class Factory
+    def self.Entity(args = {})
+      entity = Xbrlware::Entity.new(args[:identifier], args[:segment])
+
+      return entity
+    end
+
+    def self.Context(args = {})
+      id = args[:id] || ""
+      entity = args[:entity] || self.Entity()
+      period = args[:period]
+      scenario = args[:scenario]
+      context = Xbrlware::Context.new(id, entity, period, scenario)
+
+      return context
+    end
+
+    def self.Item(args = {})
+      instance = nil
+      name = args[:name] || ""
+      context = args[:context] || self.Context(:period => args[:period])
+      value = args[:value] || ""
+      unit = args[:unit]
+      precision = args[:precision]
+      decimals = args[:decimals] || "-6"
+      footnotes = nil
+      
+      item = Xbrlware::Item.new(instance, name, context, value, unit, precision, decimals, footnotes)
+
+      return item
+    end
+
+    def self.CalculationArc(args = {})
+      item_id = args[:item_id] || ""
+      href = ""
+      role = nil
+      order = nil
+      weight = nil
+      priority = nil
+      use = nil
+      label = args[:label] || ""
+
+      arc = Xbrlware::Linkbase::CalculationLinkbase::Calculation::CalculationArc.new(item_id, href, role, order, 
+                                                                                     weight, priority, use, label)
+
+      return arc
+    end
+
+    def self.Calculation(args = {})
+      entity_details=nil
+      title=args[:title] || ""
+      role=args[:role]
+      href=nil
+      arcs=args[:arcs] || []
+      contexts=nil
+
+      return Xbrlware::Linkbase::CalculationLinkbase::Calculation.new(entity_details, title, role, href, arcs, contexts)
+    end
+
+  end
+end

data/lib/xbrlware-extras/item.rb

@@ -0,0 +1,77 @@
+module Xbrlware
+
+  class ValueMapping
+    attr_accessor :policy
+
+    def initialize
+      @unknown_classifier = nil
+
+      @policy = { :credit  => :no_action,
+                  :debit   => :no_action,
+                  :unknown => :no_action } # FIXME: a classifier could be used here....
+    end
+
+    def value(name, defn, val)
+      # we ignore 'name' in this implementation
+
+      case @policy[defn]
+        when :no_action then val
+        when :flip then -val
+      end
+    end
+  end
+
+  class Item
+    def pretty_name
+      self.name.gsub(/([a-z])([A-Z])/, '\1 \2')
+    end
+
+    def write_constructor(file, item_name)
+      item_context_name = item_name + "_context"
+      if @context.nil?
+        file.puts "#{item_context_name} = nil"
+      else
+        @context.write_constructor(file, item_context_name)
+      end
+
+      file.puts "#{item_name} = Xbrlware::Factory.Item(:name     => \"#{@name}\","     +
+                "                                      :decimals => \"#{@decimals}\"," +
+                "                                      :context  => #{item_context_name}," +
+                "                                      :value    => \"#{@value}\")"
+      if !@def.nil? and !@def["xbrli:balance"].nil?
+        file.puts "#{item_name}.def = { } if #{item_name}.def.nil?"
+        file.puts "#{item_name}.def[\"xbrli:balance\"] = \"#{@def['xbrli:balance']}\""
+      end
+    end
+
+    def print_tree(indent_count=0)
+      output = "#{indent} #{@label}"
+
+      @items.each do |item|
+        period=item.context.period
+        period_str = period.is_duration? ? "#{period.value["start_date"]} to #{period.value["end_date"]}" : "#{period.value}"
+        output += " [#{item.def["xbrli:balance"]}]" unless item.def.nil?
+        output += " (#{period_str}) = #{item.value}" unless item.nil?
+      end
+      puts indent + output
+
+      @children.each { |child| child.print_tree(indent_count+1) }
+    end
+
+    def is_sub_leaf?
+      @context.entity.segment
+    end
+
+    def value(mapping=nil)
+      definition = case
+        when @def.nil?                  then :unknown
+        when @def["xbrli:balance"].nil? then :unknown
+        else                                 @def["xbrli:balance"].to_sym
+      end
+
+      mapping = mapping || ValueMapping.new
+      return mapping.value(pretty_name, definition, @value.to_f)
+    end
+  end
+
+end

data/lib/xbrlware-extras/linkbase.rb

@@ -0,0 +1,158 @@
+module Xbrlware
+
+  module Linkbase
+    class Linkbase
+      class Link
+        def clean_downcased_title
+          @title.gsub(/([A-Z]) ([A-Z])/, '\1\2').gsub(/([A-Z]) ([A-Z])/, '\1\2').downcase
+        end
+      end
+    end
+
+    class CalculationLinkbase
+      class Calculation
+        def write_constructor(file, calc_name)
+          file.puts "#{calc_name}_args = {}"
+          file.puts "#{calc_name}_args[:title] = \"#{@title}\""
+          file.puts "#{calc_name}_args[:role] = \"#{@role}\""
+          file.puts "#{calc_name}_args[:arcs] = []"
+          @arcs.each_with_index do |arc, index|
+            arc_name = calc_name + "_arc#{index}"
+            arc.write_constructor(file, arc_name)
+            file.puts "#{calc_name}_args[:arcs].push #{arc_name}"
+          end
+          file.puts "#{calc_name} = Xbrlware::Factory.Calculation(#{calc_name}_args)"
+        end
+
+        def is_disclosure?
+          @title.downcase =~ /^disclosure/ ? true : false
+        end
+
+        def top_level_arcs
+          uniq_arcs = []
+          @arcs.each do |arc|
+            if @arcs.none?{ |other_arc| other_arc.contains_arc?(arc) }
+              uniq_arcs.push arc
+            end
+          end
+
+          return uniq_arcs
+        end
+
+        def print_tree(indent_count=0)
+          indent = " " * indent_count
+          puts indent + "Calc: #{@title} (#{@role})"
+
+          @arcs.each { |arc| arc.print_tree(indent_count+1) }
+
+          puts indent + "\n\n"
+        end
+
+        def leaf_items(period)
+          #if @arcs.empty?
+          if top_level_arcs.empty?
+            raise RuntimeError.new("#{self.inspect} (#{@label}) has nil items!") if @items.nil?
+
+            items = @items.select{ |x| !x.is_sub_leaf? }
+            items.select!{ |x| x.context.period.to_pretty_s == period.to_pretty_s } if period
+
+            return items
+          end
+    
+          #return @arcs.collect { |child| child.leaf_items(period) }.flatten
+          return top_level_arcs.collect { |child| child.leaf_items(period) }.flatten
+        end
+    
+        class CalculationArc
+          def write_constructor(file, arc_name)
+            file.puts "args = {}"
+            file.puts "args[:item_id] = \"#{@item_id}\""
+            file.puts "args[:label] = \"#{@label}\""
+            file.puts "#{arc_name} = Xbrlware::Factory.CalculationArc(args)"
+            file.puts "#{arc_name}.items = []"
+            (@items || []).each_with_index do |item, index|
+              item_name = arc_name + "_item#{index}"
+              item.write_constructor(file, item_name)
+              file.puts "#{arc_name}.items.push #{item_name}"
+            end
+            file.puts "#{arc_name}.children = []"
+            (@children || []).each_with_index do |child, index|
+              child_name = arc_name + "_child#{index}"
+              child.write_constructor(file, child_name)
+              file.puts "#{arc_name}.children.push #{child_name}"
+            end
+          end
+
+          def contains_arc?(arc)
+            return false if @children.empty?
+
+            @children.each do |child|
+              return true if (child.label == arc.label) && (child.item_id == arc.item_id)
+              return true if child.contains_arc?(arc)
+            end
+
+            return false
+          end
+
+          def print_tree(indent_count=0)
+            indent = " " * indent_count
+            output = "#{indent} #{@label}"
+
+            (@items || []).each do |item|
+              period = item.context.period
+              period_str = period.is_duration? ? "#{period.value["start_date"]} to #{period.value["end_date"]}" : "#{period.value}"
+              output += " [#{item.def["xbrli:balance"]}]" if item.def
+              output += " (#{period_str}) = #{item.value}" if item.value
+            end
+            puts indent + output
+
+            (@children || []).each { |child| child.print_tree(indent_count+1) }
+          end
+
+          def leaf_items(period)
+            if @children.empty?
+              raise RuntimeError.new("#{self} (#{@label}) has nil items!") if @items.nil?
+              items = @items.select{ |x| !x.is_sub_leaf? }
+              raise RuntimeError.new("#{self} (#{@label}) has a Hash for a period") if period and period.class==Hash
+              items.select!{ |x| x.context.period.to_pretty_s == period.to_pretty_s } if period
+              return items
+            end
+      
+            return @children.collect { |child| child.leaf_items(period) }.flatten
+          end
+        end
+      end
+    end
+
+    class PresentationLinkbase
+      class Presentation
+        def print_tree(indent_count=0)
+          indent = " " * indent_count
+          puts indent + "Pres: #{@title} (#{@role})"
+
+          @arcs.each { |arc| arc.print_tree(indent_count+1) }
+
+          puts indent + "\n\n"
+        end
+
+        class PresentationArc
+          def print_tree(indent_count=0)
+            indent = " " * indent_count
+            output = "#{indent} #{@label}"
+
+            @items.each do |item|
+              period=item.context.period
+              period_str = period.is_duration? ? "#{period.value["start_date"]} to #{period.value["end_date"]}" : "#{period.value}"
+              output += " [#{item.def["xbrli:balance"]}]" unless item.def.nil?
+              output += " (#{period_str}) = #{item.value}" unless item.nil?
+            end
+            puts indent + output
+
+            @children.each { |child| child.print_tree(indent_count+1) }
+          end
+        end
+      end
+    end
+  end
+
+end

data/lib/xbrlware-extras/version.rb

@@ -0,0 +1,5 @@
+module Xbrlware
+  module Extras
+    VERSION = "1.1.2.19"
+  end
+end

data/lib/xbrlware-extras.rb

@@ -0,0 +1,8 @@
+require "xbrlware-extras/version"
+
+require "xbrlware-extras/context"
+require "xbrlware-extras/dateutil"
+require "xbrlware-extras/item"
+require "xbrlware-extras/linkbase"
+require "xbrlware-extras/factory"
+

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+# load the implementation
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..'))
+
+require 'xbrlware-ruby19'
+require 'xbrlware-extras'
+

data/spec/xbrlware_helpers_spec.rb

@@ -0,0 +1,212 @@
+# string_helpers_spec.rb
+
+require 'spec_helper'
+
+describe Xbrlware::Context::Period do
+  describe ".days" do
+    context "when a date range" do
+      let(:value) { {"start_date"=>Date.parse("2011-01-01"), "end_date"=>Date.parse("2011-03-31")} }
+      subject { Xbrlware::Context::Period.new(value).days }
+
+      it { should be_a Fixnum }
+      it { should == Xbrlware::DateUtil.days_between(value["end_date"], value["start_date"]) }
+    end
+  end
+  describe ".plus_n_months" do
+    context "when an instantaneous date" do
+      let(:old_value) { Date.parse("2010-12-31") }
+      let(:old) { old = Xbrlware::Context::Period.new(old_value) }
+
+      subject { old.plus_n_months(3) }
+
+      it { should be_a Xbrlware::Context::Period }
+      its(:to_pretty_s) { should == "2011-03-28" }
+    end
+    context "when a date range" do
+      let(:old_value) { {"start_date"=>Date.parse("2011-01-01"), "end_date"=>Date.parse("2011-03-31")} }
+      let(:old) { old = Xbrlware::Context::Period.new(old_value) }
+
+      subject { old.plus_n_months(3) }
+
+      it { should be_a Xbrlware::Context::Period }
+      its(:to_pretty_s) { should == "2011-04-01 to 2011-06-30" }
+    end
+  end
+end
+
+describe Xbrlware::Context do
+
+  describe "write_constructor" do
+    context "when the period is nil" do
+      before(:all) do
+        file_name = "/tmp/xbrlware-extras-context1.rb"
+        item_name = "@item_context"
+        file = File.open(file_name, "w")
+        @orig_item = Xbrlware::Factory.Context()
+        @orig_item.write_constructor(file, item_name)
+        file.close
+  
+        eval(File.read(file_name))
+  
+        @loaded_item = eval(item_name)
+      end
+  
+      it "writes itself to a file, and when reloaded, has the same period" do
+        @loaded_item.period.value.should == @orig_item.period.value
+      end
+    end
+
+    context "when the period is an instant" do
+      before(:all) do
+        file_name = "/tmp/xbrlware-extras-context2.rb"
+        item_name = "@item_context"
+        file = File.open(file_name, "w")
+        @orig_item = Xbrlware::Factory.Context(:period => Date.parse("2010-01-01"))
+        @orig_item.write_constructor(file, item_name)
+        file.close
+  
+        eval(File.read(file_name))
+  
+        @loaded_item = eval(item_name)
+      end
+  
+      it "writes itself to a file, and when reloaded, has the same period" do
+        @loaded_item.period.to_pretty_s.should == @orig_item.period.to_pretty_s
+      end
+    end
+
+    context "when the period is a duration" do
+      before(:all) do
+        file_name = "/tmp/xbrlware-extras-context3.rb"
+        item_name = "@item_context"
+        file = File.open(file_name, "w")
+        @orig_item = Xbrlware::Factory.Context(:period => {"start_date" => Date.parse("2010-01-01"),
+                                                              "end_date"   => Date.parse("2011-01-01")})
+        @orig_item.write_constructor(file, item_name)
+        file.close
+  
+        eval(File.read(file_name))
+  
+        @loaded_item = eval(item_name)
+      end
+  
+      it "writes itself to a file, and when reloaded, has the same period" do
+        @loaded_item.period.to_pretty_s.should == @orig_item.period.to_pretty_s
+      end
+    end
+  end
+
+end
+
+describe Xbrlware::Linkbase::CalculationLinkbase::Calculation do
+  describe ".top_level_arcs" do
+    before(:all) do
+      @calc = Xbrlware::Factory.Calculation(:title=>"Statement of Something or Other") 
+      @calc.arcs << Xbrlware::Factory.CalculationArc(:label=>"A0")
+	  @calc.arcs.first.items = []
+      @calc.arcs.first.items << Xbrlware::Factory.Item(:name=>"A0.I0")
+
+      @calc.arcs << Xbrlware::Factory.CalculationArc(:label=>"B0")
+	  @calc.arcs.last.children = []
+      @calc.arcs.last.children << Xbrlware::Factory.CalculationArc(:label=>"B0.B1")
+
+	  @calc.arcs.last.children.first.items = []
+      @calc.arcs.last.children.first.items << Xbrlware::Factory.Item(:name=>"B0.B1.I0")
+
+      @calc.arcs.last.children << @calc.arcs.first # B0 contains A0
+    end
+    subject { @calc.top_level_arcs }
+    it { should have(1).items }
+    its(:first) { should be @calc.arcs.last }
+  end
+
+  describe ".is_disclosure?" do
+    context "when its title begins with 'Disclosure'" do
+      let(:calc) { Xbrlware::Factory.Calculation(:title=>"Disclosure of Something or Other") }
+      subject { calc.is_disclosure? }
+      it { should == true }
+    end
+    context "when its title does not begin with 'Disclosure'" do
+      let(:calc) { Xbrlware::Factory.Calculation(:title=>"Statement of Something or Other") }
+      subject { calc.is_disclosure? }
+      it { should == false }
+    end
+  end
+end
+
+describe Xbrlware::Linkbase::CalculationLinkbase::Calculation::CalculationArc do
+  describe ".write_constructor" do
+    before(:all) do
+      calc = Xbrlware::Factory.Calculation(:title=>"Statement of Something or Other") 
+      calc.arcs << Xbrlware::Factory.CalculationArc(:label=>"B0")
+	  calc.arcs.last.items = []
+	  calc.arcs.last.children = []
+      calc.arcs.last.children << Xbrlware::Factory.CalculationArc(:label=>"B0.B1", :items=>[])
+	  calc.arcs.last.children.first.items = []
+      calc.arcs.last.children.first.items << Xbrlware::Factory.Item(:name=>"B0.B1.I0")
+
+      @orig_item = calc.arcs.first
+
+      file_name = "/tmp/xbrlware-extras-calc-arc.rb"
+      item_name = "@item"
+      file = File.open(file_name, "w")
+      @orig_item.write_constructor(file, item_name)
+      file.close
+
+      eval(File.read(file_name))
+      @loaded_item = eval(item_name)
+    end
+
+    it "writes itself to a file, and when reloaded, has the same item_id" do
+      @loaded_item.item_id.should == @orig_item.item_id
+    end
+    it "writes itself to a file, and when reloaded, has the same label" do
+      @loaded_item.label.should == @orig_item.label
+    end
+    it "writes itself to a file, and when reloaded, has the same number of children" do
+      @loaded_item.children.length.should == @orig_item.children.length
+    end
+    it "writes itself to a file, and when reloaded, has the same number of items" do
+      @loaded_item.items.length.should == @orig_item.items.length
+    end
+  end
+
+  describe ".contains_arc?" do
+    before(:each) do
+      @calc = Xbrlware::Factory.Calculation(:title=>"Statement of Something or Other") 
+      @calc.arcs << Xbrlware::Factory.CalculationArc(:label=>"A0")
+	  @calc.arcs.first.items = []
+      @calc.arcs.first.items << Xbrlware::Factory.Item(:name=>"A0.I0")
+
+      @calc.arcs << Xbrlware::Factory.CalculationArc(:label=>"B0")
+	  @calc.arcs.last.children = []
+      @calc.arcs.last.children << Xbrlware::Factory.CalculationArc(:label=>"B0.B1")
+
+	  @calc.arcs.last.children.first.items = []
+      @calc.arcs.last.children.first.items << Xbrlware::Factory.Item(:name=>"B0.B1.I0")
+    end
+    context "when the first arc does not contain the second arc" do
+      subject { @calc.arcs.first.contains_arc?(@calc.arcs.last) }
+      it { should == false }
+    end
+    context "when the first arc contains the second arc" do
+      before(:each) do
+        @calc.arcs.last.children << @calc.arcs.first # B0 contains A0
+      end
+
+      subject { @calc.arcs.last.contains_arc?(@calc.arcs.first) }
+      it { should == true }
+    end
+    context "when the first arc contains a second arc that contains the third arc" do
+      before(:each) do
+        @calc.arcs.last.children << Xbrlware::Factory.CalculationArc(:label=>"B0.B2")
+        @calc.arcs.last.children.last.children << @calc.arcs.first # B0.B2 contains A0
+      end
+
+      subject { @calc.arcs.last.contains_arc?(@calc.arcs.first) }
+      it { should == true }
+    end
+  end
+
+end
+

data/xbrlware-extras.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/xbrlware-extras/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Jim Lindstrom"]
+  gem.email         = ["jim.lindstrom@gmail.com"]
+  gem.description   = %q{A set of extentions that make it easier to build on top of xbrlware}
+  gem.summary       = %q{A set of extentions that make it easier to build on top of xbrlware}
+  gem.homepage      = ""
+
+  gem.add_dependency("xbrlware-ruby19", "1.1.2.19")
+
+  gem.add_development_dependency("rspec", "~> 2.0.1")
+
+  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.name          = "xbrlware-extras"
+  gem.require_paths = ["lib"]
+  gem.version       = Xbrlware::Extras::VERSION
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: xbrlware-extras
+version: !ruby/object:Gem::Version
+  version: 1.1.2.19
+  prerelease: 
+platform: ruby
+authors:
+- Jim Lindstrom
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-31 00:00:00.000000000 -04:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: xbrlware-ruby19
+  requirement: &85581660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 1.1.2.19
+  type: :runtime
+  prerelease: false
+  version_requirements: *85581660
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &85581410 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+  type: :development
+  prerelease: false
+  version_requirements: *85581410
+description: A set of extentions that make it easier to build on top of xbrlware
+email:
+- jim.lindstrom@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/xbrlware-extras.rb
+- lib/xbrlware-extras/context.rb
+- lib/xbrlware-extras/dateutil.rb
+- lib/xbrlware-extras/factory.rb
+- lib/xbrlware-extras/item.rb
+- lib/xbrlware-extras/linkbase.rb
+- lib/xbrlware-extras/version.rb
+- spec/spec_helper.rb
+- spec/xbrlware_helpers_spec.rb
+- xbrlware-extras.gemspec
+has_rdoc: true
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A set of extentions that make it easier to build on top of xbrlware
+test_files:
+- spec/spec_helper.rb
+- spec/xbrlware_helpers_spec.rb