elm_history_tools 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 280b6456a5473cc4af85ebe96dd303466bf1341d
-  data.tar.gz: d18f4ff0a50be7ddd539b0198b51d05415812151
+SHA256:
+  metadata.gz: 040e25befa828f739530f1dcbe81ba5350cae4b6c06f25fc5a7b5a66da906aed
+  data.tar.gz: ba6f918efeacfd835dde3d7fd350c7933bea913a6b6bc7518784abb15e84d35b
 SHA512:
-  metadata.gz: b9e621128a84df9e1ee1c84369cff2bb46c6fe7800a664b40ac3f64dc58efa028b140229f2b20693ab7390e3e3e02c319d980416316c0acc0f832c52283a460e
-  data.tar.gz: 9e7c57afa830d958f2fcce36d9894227605d4afb810a32f6ff679211068327e4c29cb37dc99e60651e8139bacaeadd8912bf1655f316fc7e5c37bc5a8fc3bf75
+  metadata.gz: 8eace2f01d5e3af2940fa086b57723a33e54c0a2e6f58499186511d0dd9809cf348d248a9aa6d13f219d5bc4fe37bad355c5d3555bdeeb9e8b47b938f096e67c
+  data.tar.gz: 8d503d9254bf9258878591c12e3e59fa5f06bf26d97a68eff5b67fc222b1d9e23dab5eaa85bd77ad11f1bdbcf4869da2736345f95cfec2da0e1d64977253395e

data/README.md

@@ -100,89 +100,8 @@ You can then easily loop over this data in Ruby to present a readable internal d
 
 ## Elm History Export Format
 
-The Elm 0.18.0 history export is structured as followed:
-
-```js
-{
-  "metadata": {
-    "versions": {"elm": "0.18.0"},
-    "types": {
-      // the Message type used by your program
-      "message": "Message.Message",
-      // all the type aliases defined in your program
-      "aliases": {
-        "Json.Decode.Value": {"args":[],"type":"Json.Encode.Value"},
-        // etc.
-      },
-      // all the union types used in your program
-      "unions": {
-        "Maybe.Maybe": {
-          // what arguments the union type takes
-          "args": ["a"],
-          // what tags/constructors make up that union type and what arguments they take
-          "tags":{
-            "Just": ["a"],
-            "Nothing": []
-          }
-        }
-      }
-    }
-  }
-  // what's happened in user session being exported
-  "history": [
-    // each entry is stored with the contructor and any ordered arguments passed to it
-    {"ctor": "MessageType", "_0": "Arg1", "_02": {"ctor": "AnotherType"}},
-    {"ctor": "AnotherMessageType", "_0": "AnotherArg"},
-    // etc.
-  ]
-}
-```
-
-Each entry in the history hash represents an Elm message object -- so
-
-```js
-{"ctor": "MessageType", "_0": "Arg1", "_02": {"ctor": "AnotherType"}},
-```
-
-represents the Elm message
-
-```elm
--- if type alias SomeType = AnotherType | SomethingElse
---
--- MessageType String SomeType
-MessageType "Arg1" AnotherType
-```
-
-A few notes:
-
-**Lists**
-
-List entries are recursively nested objects whose constructor is `::` (cons).
-
-As an example, an Elm list of three books (`[{title = "Too Like the Lightning"}, {title = "The Fear of Barbarians"}, {title = "Evicted"}]`) would be represented as:
-
-```js
-{
-  "ctor": "::",
-  "_0": {"title": "Too Like the Lightning"},
-  "_1": {
-    "ctor": "::",
-    "_0": {"title": "The Fear of Barbarians"},
-    "_1": {
-      "ctor": "::",
-      "_0": {"title": "Evicted"}
-    }
-  }
-}
-```
-
-This is because in Elm, `List` is implemented as a linked list (each element is an object that both stores its value and points to the next element in the list, rather than sitting in an array of plain values).
-
-You don't need to know anything about linked lists to use Elm (or Javascript or Ruby or, likely, whatever you're using for work or fun -- I've literally never used them in my career), but if you're curious, you can read more about them [on Wikipedia](https://en.wikipedia.org/wiki/Linked_list). You can also check out [this interesting discussion](https://github.com/elm-lang/elm-plans/issues/13) of Arrays vs. Lists in Elm.
-
-**In the future**
-
-It looks like the terms will change somewhat in a future version of Elm:  `"ctor"` and `"_01"`, `"_02"`, etc. will be [replaced with `$`, `a`, `b`, etc](https://github.com/elm-lang/virtual-dom/commit/61cf2090ecb745542532dd7ea87de37c6ed6c3b4#diff-25d902c24283ab8cfbac54dfa101ad31). ElmHistoryTools will support both formats in the future; should the structure change, obviously that will be addressed too.
+For more information on the Elm history export format, see [this blog
+post](https://medium.com/@arsduo/understanding-an-elm-0-19-history-export-1bca38613840).
 
 **Why hashes?**
 

data/lib/elm_history_tools/history_formatter.rb

@@ -2,35 +2,35 @@ module ElmHistoryTools::HistoryFormatter
   # Given a raw Elm history file parsed to JSON, return a simplified hash of the history.
   #
   # For instance, given an array like:
-  # [{"ctor": "MessageType", "_0": "Arg1", "_02": {"ctor": "AnotherType"}}]
+  # [{"$": "MessageType", "a": "Arg1", "a2": {"$": "AnotherType"}}]
   #
   # you'll get
   #
   # [{"MessageType" => ["Arg1", {"AnotherType" => []}]}]
   #
   def self.to_simple_hash(history_data)
-    history_data["history"].map do |entry|
+    history_data.dig("a", "history").map do |entry|
       simplify_history_entry(entry)
     end
   end
 
   # Turn an Elm history entry into a simple Ruby hash, as described above.
   #
-  # Constructors that take no arguments are represented as taking an empty list (see above); an
+  # Constru$s that take no arguments are represented as taking an empty list (see above); an
   # alternative approach would be to use nil. While that would clearly distinguish between those
   # cases, it would make working with the results more complicated.
   def self.simplify_history_entry(entry)
     ElmHistoryTools::Utils.transform_object(entry) do |object_hash|
-      if object_hash["ctor"] == "::"
-        # Elm lists are represented as nested entries with the contructor ::. (See the readme for
+      if object_hash["$"] == "::"
+        # Elm lists are represented as nested entries with the contru$ ::. (See the readme for
         # more detail.)
         # We collapse those into a proper Ruby array via flatten.
         # The last entry of the list will have no nested entry, so we use compact to remove the nil.
-        [simplify_history_entry(object_hash["_0"]), simplify_history_entry(object_hash["_1"])].compact.flatten
-      elsif object_hash["ctor"]
+        [simplify_history_entry(object_hash["a"]), simplify_history_entry(object_hash["b"])].compact.flatten
+      elsif object_hash["$"]
         # we have an Elm object type (we know this because non-objects aren't passed to the block)
         {
-          object_hash["ctor"] => object_hash.reject {|k, _v| k == "ctor"}.values.map {|val| simplify_history_entry(val) }
+          object_hash["$"] => object_hash.reject {|k, _v| k == "$"}.values.map {|val| simplify_history_entry(val) }
         }
       end
     end

data/lib/elm_history_tools/history_sanitizer.rb

@@ -20,21 +20,23 @@ module ElmHistoryTools::HistorySanitizer
   # further.
   def self.sanitize_history(history_data, watch_words, &sanitizing_block)
     matchers = watch_words.map {|word| word.is_a?(Regexp) ? word : Regexp.new(word, true)}
-    history_data.dup.merge(
-      "history" => history_data["history"].map {|entry| sanitize(entry, matchers, &sanitizing_block)}
+    data = history_data.dup
+    data["a"].merge!(
+      "history" => data["a"]["history"].map {|entry| sanitize(entry, matchers, &sanitizing_block)}
     )
+    data
   end
 
   # For each entry, we sanitize it if there's a matching handler. If there is no sanitizer, see if
   # any data in the entry merit flagging against a watch word.
   def self.sanitize(entry, matchers, &sanitizing_block)
     ElmHistoryTools::Utils.transform_object(entry) do |elm_object|
-      constructor = elm_object["ctor"]
+      constructor = elm_object["$"]
       raise ElmObjectExpected unless constructor
 
       # replace any records that need it
       cleaned_object = elm_object.each_with_object({}) do |(key, value), hash|
-        if value.is_a?(Hash) && value["ctor"]
+        if value.is_a?(Hash) && value["$"]
           # we have an elm object -- sanitize that
           hash[key] = sanitize(value, matchers, &sanitizing_block)
         elsif value.is_a?(Hash)

data/lib/elm_history_tools/utils.rb

@@ -9,7 +9,7 @@ module ElmHistoryTools::Utils
   def self.transform_object(entry, &block)
     if !entry.is_a?(Hash)
       entry
-    elsif entry["ctor"]
+    elsif entry["$"]
       # If you want to walk down sub-entries, call transform_object within your block.
       yield entry
     else

data/lib/elm_history_tools/version.rb

@@ -1,3 +1,3 @@
 module ElmHistoryTools
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: elm_history_tools
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Alex Koppel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-05 00:00:00.000000000 Z
+date: 2019-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -81,7 +81,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: Tools to work with Elm history exports.