paru 0.3.0.1 → 0.3.1.0.a

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 3dd51d6ba5f8dc6542535bb8717ab3da0264cb5b6256486b2894bddbee8099d3
-  data.tar.gz: 931d68edec6acc217278d5505c527746b4ec722187b3e0ba50e4bfeb6532c2e1
+SHA1:
+  metadata.gz: 38bef6b5bd0c2c11c1b636159c0d19f3f61d8696
+  data.tar.gz: 64bbaee8ba0e98d000888ad230347e5586699135
 SHA512:
-  metadata.gz: 9164982754224b190dcc7782b684ec0cf3aad0abcbe250d5ad566f6c3b18d7cc1952477993f5830a166fba4ffaa0524d54c03f7bab89ef50f3217c21fca30f1c
-  data.tar.gz: aaaf68c9f181e71c52127806b78c477c35c9191999b8f7587a3bbff1f5105385ca5654348e77fe91ced494170d2d01fc1d27793841877e3f5bd9d226a88dd9f8
+  metadata.gz: 20be16827b545e7287f4409b0ce7fafbcd3be2b949ba723f727af88370ddbe155646436e29193729b007a62a202e5a3622efc174939d3dec2e994608ffcddf1e
+  data.tar.gz: 256d22abf8bf5385e99e12c8c3ea826cc30386f7aaef80a87523162afbaf7bebda26884a584c4dd73dfeef55c130f031097020619257bce9b5f1d9860566ea7d

data/lib/paru.rb

@@ -18,5 +18,5 @@
 #++
 module Paru
     # Paru's current version
-    VERSION = [0, 3, 0, 1]
+    VERSION = [0, 3, 1, 0, "a"]
 end

data/lib/paru/filter/bullet_list.rb

@@ -22,6 +22,16 @@ module Paru
     module PandocFilter
         # BulletList, contains a list of list of Block nodes.
         class BulletList < List
+
+            # Create a new BulletList from an array of markdown strings
+            #
+            # @param items [String[]] array of markdown strings as items of
+            #   the new BulletList
+            # @return [BulletList]
+            def self.from_array(items)
+                ast_items = items.map {|item| [Block.from_markdown(item).to_ast]}
+                BulletList.new ast_items
+            end
         end
     end
 end

data/lib/paru/filter/code_block.rb

@@ -57,6 +57,48 @@ module Paru
             def has_string?()
                 true
             end
+
+            # Write this CodeBlock's contents to file
+            #
+            # @param filename {String} the path to the file to write
+            def to_file(filename)
+                File.open(filename, "w") do |file|
+                    file.write "#{@string}\n"
+                end
+            end
+
+            # Create a new CodeBlock based on the contents of a file, and,
+            # optionally, a language
+            #
+            # @param filename {String} the path to the file to read the
+            #   contents from
+            # @param language {String} the language of the contents
+            #
+            # @return [CodeBlock]
+            def self.from_file(filename, language = "")
+                return self.from_code_string(File.read(filename), language) 
+            end
+
+            # Get this CodeBlock's contents as a string
+            #
+            # @return [String]
+            def to_code_string()
+                return @string
+            end
+
+            # Create a new CodeBlock based on a string and, optionally, a
+            # language
+            # 
+            #
+            # @param code_string [String] the string with code to use as the
+            #   contents of the CodeBlock
+            # @param language [String] the optional language class
+            # @return [CodeBlock]
+            def self.from_code_string(code_string, language = "")
+                attributes = ["", [language], []]
+                code_block = CodeBlock.new [attributes, code_string]
+                return code_block
+            end
         end
     end
 end

data/lib/paru/filter/definition_list.rb

@@ -17,6 +17,8 @@
 # along with Paru.  If not, see <http://www.gnu.org/licenses/>.
 #++
 require_relative "./block.rb"
+require_relative "./list.rb"
+require_relative "./para.rb"
 
 module Paru
     module PandocFilter
@@ -37,6 +39,39 @@ module Paru
                 @children.map {|child| child.to_ast}
             end
 
+            # Convert this DefinitionList to a hash of term => definitions
+            #
+            # @return [Array]
+            def to_array()
+                @children.map do |def_item|
+                    def_item.to_array 
+                end
+            end
+
+            # Create a new DefinitionList based on a hash of term =>
+            # definitions
+            #
+            # @param definitions [Array] Array of arrays with terms and their definitions
+            # @return [DefinitionList] 
+            def self.from_array(definitions)
+                ast_items = definitions.map do |definition| 
+                    term = Block.from_markdown(definition[0]).ast_contents
+                    defin = List.from_markdown(definition[1])
+
+                    if not defin.has_block?
+                        para = Para.new []
+                        para.inner_markdown = definition[1]
+                        defin = [para.to_ast]
+                    else
+                        defin = defin.children.map{|c| c.to_ast}
+                    end
+
+                    [term, [defin]]
+                end
+
+                DefinitionList.new ast_items
+            end
+
         end
     end
 end

data/lib/paru/filter/definition_list_item.rb

@@ -48,6 +48,15 @@ module Paru
                     @definition.ast_contents
                 ]
             end
+
+            # Convert this DefinitionListItem to a pair of term and definition
+            #
+            # @return [Array]
+            def to_array
+                term = @term.children.map{|c| c.markdown.strip}.select{|c| !c.empty?}.join(" ").strip
+                definition = @definition.children.map{|c| c.children.map{|d| d.markdown}}.join("\n").strip
+                [term, definition]
+            end
         end
     end
 end

data/lib/paru/filter/list.rb

@@ -46,6 +46,16 @@ module Paru
             def has_block?()
                 true
             end
+
+            # Convert this List to an array of markdown strings
+            #
+            # @return [String[]]
+            def to_array()
+                @children.map do |block|
+                    block.children.map{|c| c.markdown.strip}.join("\n")
+                end
+            end
+
         end
     end
 end

data/lib/paru/filter/ordered_list.rb

@@ -18,6 +18,7 @@
 #++
 require_relative "./list.rb"
 require_relative "./list_attributes.rb"
+require_relative "./block.rb"
 
 module Paru
     module PandocFilter
@@ -53,6 +54,21 @@ module Paru
                 ] 
             end
 
+            # Create a new OrderedList from an array of markdown strings
+            #
+            # @param items [String[]] an array of markdown strings
+            # @param config [Hash] configuration of the list. Can have
+            # properties :start (Int), :style (String), and :delim (String)
+            #
+            # @return [OrderedList]
+            def self.from_array(items, **config )
+                start = if config.has_key? :start then config[:start] else 1 end
+                style = if config.has_key? :style then config[:style] else "Decimal" end
+                delim = if config.has_key? :delim then config[:delim] else "Period" end
+                ast_items = items.map {|item| [Block.from_markdown(item).to_ast]}
+                OrderedList.new [[start, {"t" => style}, {"t" => delim}], ast_items]
+            end
+
         end
     end
 end

data/lib/paru/filter/table.rb

@@ -16,6 +16,7 @@
 # You should have received a copy of the GNU General Public License
 # along with Paru.  If not, see <http://www.gnu.org/licenses/>.
 #++
+require "csv"
 require_relative "./block.rb"
 require_relative "./inline.rb"
     
@@ -70,6 +71,112 @@ module Paru
                     @children.map {|row| row.ast_contents}
                 ]
             end
+
+            # Convert this table to a 2D table of markdown strings for each
+            # cell
+            #
+            # @param config [Hash] configuraton of the table output
+            #   Config can contain properties :headers
+            #
+            # @return [String[][]] This Table as a 2D array of cells
+            # represented by their markdown strings.
+            def to_array(**config)
+                headers = if config.has_key? :headers then config[:headers] else false end
+
+                data = []
+                if headers then
+                    data.push @headers.to_array
+                end
+
+                @children.each do |row|
+                    data.push row.to_array
+                end
+
+                data
+            end
+
+            # Convert this Table to a CSV file. See to_array for the config
+            # options
+            #
+            # @param filename [String] filename to write to
+            # @param config [Hash] See #to_array for config options
+            def to_file(filename, **config)
+                CSV.open(filename, "wb") do |csv|
+                    to_array(config).each {|row| csv << row}
+                end
+            end
+
+            # Create a new Table from an 2D array and an optional
+            # configuration
+            #
+            # @param data [String[][]] an array of markdown strings
+            # @param config [Hash] configuration of the list.
+            #   properties:
+            #     :headers [Boolean] True if data includes headers on first
+            #     row
+            #     :caption [String] The table's caption
+            #     :alignment [String[]] An array with alignments for each
+            #     column. Should have an alignment for all columns. Defaults
+            #     to "AlignLeft"
+            #     :widhts [Number[]] An array with column widths. Should have
+            #     a width for all columns. Use 0 for no set width. Defaults to
+            #     0
+            #
+            # @return [Table]
+            def self.from_array(data, **config)
+                return Table.new [[],[],[],[],[]] if data.empty? 
+
+                headers = if config.has_key? :headers then 
+                              config[:headers] 
+                          else 
+                              false 
+                          end
+                caption = if config.has_key? :caption then 
+                              Block.from_markdown(config[:caption]).ast_contents 
+                          else 
+                              [] 
+                          end
+
+                alignment = if config.has_key? :alignment then 
+                                config[:alignment].map {|a| {"t" => "#{a}"}} 
+                            else
+                                data.first.map {|_| {"t"=>"AlignLeft"}}
+                            end
+
+                widths = if config.has_key? :widths then
+                            config[:widths] 
+                         else
+                             data.first.map {|_| 0}
+                         end
+
+                header = []
+                rows = data
+                if headers then
+                    header = data.first
+                    header = header.map {|cell| [Block.from_markdown(cell).to_ast]}
+                    rows = data.slice(1..-1)
+                end
+                
+                rows = rows.map {|row| row.map {|cell| [Block.from_markdown(cell).to_ast]}}
+
+                Table.new [caption, alignment, widths, header, rows]
+            end
+
+
+            # Create a new Table from a CSV file.
+            #
+            # @param filename [String] filename to read CSV data from
+            # @param config [Hash] See #from_file for details
+            #
+            # @return [Table]
+            def self.from_file(filename, **config) 
+                data = []
+                CSV.foreach(filename) do |row|
+                    data << row
+                end
+
+                return self.from_array(data, config) 
+            end
         end
     end
 end

data/lib/paru/filter/table_row.rb

@@ -38,6 +38,16 @@ module Paru
             def ast_contents
                 @children.map {|child| child.ast_contents}
             end
+
+            # Convert this TableRow to an array of markdown strings, one for
+            # each cell
+            #
+            # @return [String[]] An Array representation of this TableRow.
+            def to_array()
+                @children.map do |cell|
+                    cell.children.map{|c| c.markdown.strip}.join("\n")
+                end
+            end
         end
     end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: paru
 version: !ruby/object:Gem::Version
-  version: 0.3.0.1
+  version: 0.3.1.0.a
 platform: ruby
 authors:
 - Huub de Beer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-05 00:00:00.000000000 Z
+date: 2018-07-05 00:00:00.000000000 Z
 dependencies: []
 description: Use Pandoc (http://www.pandoc.org) with ruby
 email: Huub@heerdebeer.org
@@ -99,15 +99,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.3.7
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 2.5.2.1
 signing_key: 
 specification_version: 4
 summary: Paru is a ruby wrapper around pandoc