prison_parser 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 75a9c80e97dedb4608da793cacfdc8fa6905d4f2
+  data.tar.gz: 9346ac58194348db220677e267918375cb78be48
+SHA512:
+  metadata.gz: a0438293e09a82e458a9a2ae476e2858dff53a449d69caf728f9c455db1845d3f0cc4b0ffe440b7cfb0d9414df7c658d275bccbf583550ec6280b0113d98c6de
+  data.tar.gz: ab4562d8aa3f1439c2bf6f67eec72d14a28ee6f5e79334dd1d19a42f2df39dc12516f9cd39cf955aafa5309d5ee1ed38fb614c6bec5c8831b8446152e3ae88a2

data/.gitignore

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

data/.yardopts

@@ -0,0 +1,6 @@
+--no-cache
+--no-private
+--hide-void-return
+--output-dir ./docs
+--readme README.md
+lib/**/*.rb

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Mitch Dempsey
+
+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,39 @@
+# Prison Architect Parser
+
+This gem allows you to parse, access, and manipulate a save file from Prison Architect.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'prison_parser'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install prison_parser
+
+## Usage
+
+```ruby
+require 'prison_parser'
+prison = PrisonParser::Prison.open("myprison.prison")
+
+puts prison.Finance.Balance # 1318560.0
+
+prison.save("newprison.prison")
+
+```
+
+## Roadmap
+
+* Ability to convert a prison to a blank, but planned prison.
+
+## Thanks
+Special thanks to: [Matvei Stefarov](https://github.com/fragmer) for his work on [PASaveEditor](https://github.com/fragmer/PASaveEditor), which served as the basis for the parsing implementation. To [Jason Dew](https://github.com/jasondew) for letting me use the name of his original library, [prison_parser](https://github.com/jasondew/prison_parser)
+
+## License
+Please see the [LICENSE](https://github.com/webdestroya/prison_parser/LICENSE) for more information.

data/Rakefile

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

data/lib/prison_parser.rb

@@ -0,0 +1,9 @@
+module PrisonParser
+
+end
+
+require_relative "prison_parser/version"
+require_relative "prison_parser/node"
+require_relative "prison_parser/models"
+require_relative "prison_parser/prison"
+require_relative "prison_parser/utils"

data/lib/prison_parser/models.rb

@@ -0,0 +1,7 @@
+module PrisonParser
+  module Models
+
+  end
+end
+require_relative "models/base"
+require_relative "models/finance"

data/lib/prison_parser/models/base.rb

@@ -0,0 +1,11 @@
+module PrisonParser
+  module Models
+    class Base < Node
+      def initialize
+        class_name = self.class.name
+        label = class_name[(class_name.rindex("::") + 2)..-1]
+        super(label)
+      end
+    end
+  end
+end

data/lib/prison_parser/models/finance.rb

@@ -0,0 +1,7 @@
+module PrisonParser
+  module Models
+    class Finance < Base
+
+    end
+  end
+end

data/lib/prison_parser/node.rb

@@ -0,0 +1,99 @@
+module PrisonParser
+  class Node
+    attr_reader :nodes
+    attr_reader :properties
+    attr_reader :label
+
+    attr_accessor :allow_inline
+
+    def initialize(label=nil)
+      @label = label
+      @nodes = Hash.new
+      @properties = Hash.new
+      @allow_inline = true
+    end
+
+    def method_missing(name, *args, &block)
+      # Look in Nodes
+      # Look in properties
+      # if ends with ?, cast property to boolean
+      # else SUPER      
+
+      if nodes.has_key?(name.to_s)
+        nodes[name.to_s]
+      elsif properties.has_key?(name.to_s)
+        properties[name.to_s]
+      else
+        super
+      end
+    end
+
+    def allow_inline?
+      @allow_inline
+    end
+
+    def inspect
+      str = StringIO.new("")
+      str.write "<#{label} "
+      str.write properties.entries.map { |e|"#{e[0]}=\"#{e[1]}\"" }.join(", ")
+      str.write ">"
+      str.string
+    end
+
+    # ReadKey, PushProperty
+    def add_property(key, value)
+      return if key == "BEGIN" || key == "END"
+      if properties[key]
+        if properties[key].is_a?(Array)
+          @properties[key] << value
+        else
+          @properties[key] = [properties[key], value]
+        end
+      else
+        @properties[key] = value
+      end
+    end
+
+    def create_node(node_label)
+      node = Node.new(node_label)
+      if nodes.has_key?(node_label)
+        if nodes[node_label].is_a?(Array)
+          @nodes[node_label] << node
+        else
+          @nodes[node_label] = [nodes[node_label], node]
+        end
+      else
+        @nodes[node_label] = node
+      end
+      node
+    end
+
+    def finished_reading_node(node)
+      # do nothing
+    end
+
+
+    # WRITING
+
+    def write_nodes(writer)
+      nodes.values.each do |node|
+        if node.is_a?(Array)
+          node.map { |n| writer.write_node(n) }
+        else
+          writer.write_node(node)
+        end
+      end
+    end
+
+    def write_properties(writer)
+      properties.each_pair do |k,value|
+        if value.is_a?(Array)
+          value.map { |v| writer.write_property(k, v) }
+        else
+          writer.write_property(k, value)
+        end
+      end
+    end
+
+  end
+end

data/lib/prison_parser/prison.rb

@@ -0,0 +1,30 @@
+module PrisonParser
+  class Prison < Node
+
+    def initialize
+      super("Prison")
+    end
+
+    # Open a prison from the file specified
+    def self.open(filename)
+      PrisonParser::Utils::Parser.new.load(filename)
+    end
+
+    # Save the prison to the specified filename
+    def save(filename)
+      file = File.open(filename, "w+")
+      PrisonParser::Utils::Writer.new(file).write_prison(self)
+    end
+
+    def create_node(node_label)
+      if PrisonParser::Models.const_defined?(node_label)
+        node = PrisonParser::Models.const_get(node_label).new
+        @nodes[node.label] = node
+        node
+      else
+        super
+      end
+    end
+
+  end
+end

data/lib/prison_parser/utils.rb

@@ -0,0 +1,8 @@
+module PrisonParser
+  module Utils
+
+  end
+end
+
+require_relative "utils/parser"
+require_relative "utils/writer"

data/lib/prison_parser/utils/parser.rb

@@ -0,0 +1,118 @@
+module PrisonParser
+  module Utils
+    class Parser
+
+      attr_reader :tokens
+
+      def initialize
+        @tokens = []
+      end
+
+      def load(filepath)
+        line_num = 0
+        nodes = []
+        @tokens = []
+        currentNode = Prison.new
+
+        file = File.open(filepath, "r")
+
+        while !file.eof? do
+          line = file.readline.strip
+          line_num += 1
+          tokenize(line)
+
+          next if tokens.size == 0
+
+          # start a new node
+          if "BEGIN" == tokens[0]
+            nodes.push(currentNode)
+
+            label = tokens[1]
+            currentNode = currentNode.create_node(label)
+
+            if tokens.size > 2
+              # inline node
+              if tokens.size % 2 != 1
+                raise "Unexpected number of tokens in an inline node definition on line #{line_num}"
+              end
+
+              unless "END" == tokens[tokens.size - 1]
+                raise "Unexpected end of inline node definition on line #{line_num}"
+              end
+              
+              tokens.each_slice(2) do |parts|
+                # the first one is bogus :/
+                currentNode.add_property(parts[0], parts[1])
+              end
+              
+              upperNode = nodes.pop
+              upperNode.finished_reading_node(currentNode)
+              currentNode = upperNode
+            else
+              currentNode.allow_inline = false
+            end
+          elsif "END" == tokens[0]
+            # end of multi-line section
+            upperNode = nodes.pop
+            upperNode.finished_reading_node(currentNode)
+            currentNode = upperNode
+          else
+            # inside a multi-line section
+            currentNode.add_property(tokens[0], tokens[1])
+          end
+        end
+
+        if nodes.size != 0
+          raise "Unexpected end of file!"
+        end
+
+        currentNode
+      end
+
+      # Splits a line into a series of tokens
+      def tokenize(line)
+        return if line.size == 0
+        
+        @tokens.clear
+        
+        token_start = 0
+        i = 0
+        chars = line.chars
+
+        while i < line.size do
+          c = chars[i]
+          if c == ' '
+            # eat the spaces!
+            if token_start != i
+              @tokens << line[token_start, i - token_start]
+            end
+            token_start = i + 1
+          elsif c == '"'
+            # skip ahead to the next quote
+            end_quotes = line.index('"', i + 1)
+
+            end_quotes = -1 if end_quotes.nil?
+
+            @tokens << line[i + 1, end_quotes - i - 1]
+            i = end_quotes
+            token_start = i + 1
+          else
+            # skip ahead to the next space
+            next_space = line.index(' ', i)
+            next_space = -1 if next_space.nil?
+            i = next_space - 1
+            break if (i < 0)
+          end
+          i += 1
+        end
+        
+        if token_start < line.size
+          # append the remainder of the string, after we ran out of spaces
+          @tokens << line[token_start, line.size - token_start]
+        end
+
+        return @tokens
+      end
+    end
+  end
+end

data/lib/prison_parser/utils/writer.rb

@@ -0,0 +1,96 @@
+module PrisonParser
+  module Utils
+    class Writer
+      INDENT_STR = "    "
+
+      attr_reader :stream
+      
+
+      def initialize(stream=nil)
+        @stream = stream || StringIO.new("")
+        @inline = false
+        @inline_stack = []
+        @indent = 0
+      end
+
+      def write_prison(prison)
+        write "\n"
+        write_node_data(prison)
+        self
+      end
+      
+      def write_node(node)
+        return nil if node.nil?
+        @inline_stack.push(@inline)
+        @inline = node_inline?(node)
+
+        write_indent
+        @indent += 1
+        write "BEGIN "
+        write_value node.label
+
+        if @inline
+          write "  "
+        else
+          write "\n"
+        end
+
+        write_node_data(node)
+
+        @indent -= 1
+
+        write_indent unless @inline
+        write "END\n"
+
+        @inline = @inline_stack.pop
+
+        self
+      end
+
+      def write_indent(indent = nil)
+        indent ||= @indent
+        return if indent <= 0
+        write INDENT_STR*indent
+      end
+
+      def write_property(key, value)
+        return if value.nil?
+
+        write_indent unless @inline
+
+        write_value key
+        write " "
+        write_value value
+
+        write (@inline ? "  " : "\n")
+
+      end
+
+      def write_node_data(node)
+        node.write_properties(self)
+        node.write_nodes(self)
+      end
+
+      def write_value(value)
+        if quote?(value)
+          write "\"#{value}\""
+        else
+          write value
+        end
+      end
+
+      def node_inline?(node)
+        node.nodes.size == 0 && node.properties.size < 13 && node.allow_inline?
+      end
+
+      def quote?(value)
+        !value.index(' ').nil?
+      end
+
+      def write(data)
+        stream.write data
+      end
+
+    end
+  end
+end