Title photo
frugal technology, simple living and guerrilla large-appliance repair
Thu, 09 Nov 2017

Overcoming a permission error while using Ruby to move files

I'm not sure if this is a Windows-specific problem (I am currently developing on Windows 10), but part of the Ruby script in my Blog Poster app allows the user to "archive" all of the text files created as blog/social posts by moving them from the main program directory to an archives directory. I could opt not to create files at all, or have the script continue to overwrite the same one for each post.

But for now I'm keeping all of the text files (which the script creates and names based on the <title> tag of URLs that are part of the post, and I have an option to move those text files to the archive directory:

Dir.glob("*.txt") {|f| FileUtils.move File.expand_path(f), "archive" }

This part of the Ruby script worked fine when I started it and was doing nothing else, but if I used it to create one or more files, invoking the "archive" feature would error out and kill the script, saying that there was a permission issue.

Laziness. I looked in Stack Overflow and found the solution, which consisted of adding :force => true to the expression:

Dir.glob("*.txt") {|f| FileUtils.move File.expand_path(f), "archive", :force => true }

Now I can create posts (and their matching .txt files, which my blog uses) and then archive them at any point without the permission error killing the script. Thanks, Stack Overflow user mudasobwa.

Update: This modification allowed the script to keep running, but any files created during the current session are NOT moved to the archive directory.

The reason the files created during the session were not deletable is due to the script reading them out in the console. I will figure out a way to provide this output without rendering the files "undeletable" via Ruby.

Here are the lines I am removing for now:

puts "This is your file:\n\n"
File.open( @yourFileName ).each do |line|
   puts line
end
Mon, 23 Oct 2017

The Ruby Terminal Apps Toolkit could solve many problems

I'm not quite sure how I stumbled upon the Ruby Terminal Apps Toolkit, but the gems included can definitely speed your development of interactive Ruby apps on the command line.

I just coded a menu for my app, and these gems by Piotr Murach offer a lot of ways to do this easily and to solicit and process user input.

The next thing I'm looking at doing in my app is allowing users to open lines for editing in their text editor of choice, and these TTY gems definitely do that. I wasn't thinking that shelling out to an editor would be so hard (meaning that was something that Ruby can do with no gems), but maybe this is a better (or easier) way.

The "hard" part in allowing user editing in my app is that I am assembling files to upload from a series of variables, and I think I'll have to create temporary files for editing that only include the component being modified (i.e. title, text, link, filename) because my app knows how to turn variables into a file but not a file into a series of variables, though that is something I could code into it. (But I may not do this because I am thinking of going in another direction and not creating actual files on the system at all and using Ruby to stream the data via FTP.)

That's more detail without context about the app I'm working on than you need.

tl;dr: The Ruby Terminal Apps Toolkit can speed up development of command-line based apps. You can use single gems or the whole thing. It's up to you.

I got an automatic Java update in Windows

Since I installed the JDK instead of the JRE, I didn't know if automatic Java updates would come at all and would cover the development portion of the tools.

I got the update today, and as you can see from the image above of my Windows command line, all is updated.

Sat, 21 Oct 2017

My blog-posting program in Ruby

I'm actually doing it. I'm writing a blog-posting program that will take an http link, extract the remote page's title and create a social-media-style blog post (title, body text and link) that can be easily uploaded to my flat-file blogging system's server.

The idea is to make it as easy to post a "social"-style update to my own blog as it is to post to Twitter (or Facebook or Google+).

(I use IFTTT -- and formerly dlvr.it -- to post these social entries on Twitter, but I could see this program taking over that task as well.)

Back to my application. I could have gone several different ways from a conceptual standpoint.

  • I could have done this idea as a web app, but in order to get the files to upload to the blog, I'd either have to write a server component on that side, or create a backend service -- with some measure of security -- to handle the upload (I'm using FTP, but it doesn't have to be that).

  • I thought about a desktop GUI. I want this to be a true cross-platform app. I seriously considered using the now-ancient Tk framework with Ruby. I less-seriously considered Java FX, though I did successfully hack together code to upload via FTP using Java. (At least it was a worthwhile programming exercise.) I could have gone with QT. Maybe I could have done the whole thing with QML.

I'm not ruling out any of these GUI solutions, but I needed to start coding, and the easiest, quickest thing for me to do (or so I thought) is a menu-driven console app. I could have gone with Java, JavaScript, Ruby, even Perl. I did tests of various components in three of those languages.

I'm writing the app for the console with an eye toward re-using the code in a future GUI app, and for that reason maybe I should have used JavaScript.

But I really wanted to use Ruby. I'm trying to grasp object-orientated programming, and there is a whole lot of web-based help for Ruby programmers that often acknowledges that there are beginners out there who need a helping hand.

And I really would love to eventually port this code to Tk, or even as a Sinatra or Rails app. I should want to do it in JavaScript. But Ruby is so friendly, and it's made for use in the console.

So I'm writing it in Ruby. And I have some 190 lines of code that do the following:

  • Display a menu of tasks and wait for input
  • When a URL is entered, grab the HTML title
  • Create a simple document with a title and text derived from the remote HTML title
  • Add a Markdown-formatted link back to the original HTML page
  • Save all as a text file with an auto-generated file name incorporating the current date and text derived from the title
  • Allow user to enter different text for the title or body
  • Let user choose not to include the source site's URL
  • Save all to a text file
  • Upload to website via FTP and "tell" blog to index the new entry

I have all of these features working, and while the app is very far from perfect, it is functional. The code isn't ready for public consumption -- it needs lots of cleanup before I publish it, and it's really meant more for Ode users and blogs that work in a similar way (files are uploaded to a server, from which the blog software renders them for the reader) than it is for flat-file systems such as Hugo, where a dedicated program builds the blog locally and sends files on their way, but the concepts and code used in this app can certainly be modified for that workflow -- and I'm not at all above doing that in the future.

Aside from adding more features, primarily the ability to edit elements instead of re-typing them (maybe by invoking the vi editor), I want to make the code more modular. Right how it's a huge procedural hack, and modularity (and object orientation) will make it cleaner and more flexible. That's the idea anyway.

Before that I need to clean up the configuration, which is all over the place.

Still, I wanted to make an app, I used the skills I had (and Googled and read plenty), and now I have something that works, however ugly it may look on the back end.

Sun, 17 Sep 2017

Building a Twitter clone with Meteor

From The Meteor Chef:

Wed, 26 Jul 2017

Free book: The JavaScript Way

I just heard about "The JavaScript Way," a book by http://www.bpesquet.com/ that is https://github.com/bpesquet/thejsway/ and a minimum of https://leanpub.com/thejsway.

It bills itself as beginner-friendly yet written to ES2015 standards. I took a quick look, and so far I like it.

Sat, 15 Jul 2017

Meteor Forums: Why I fell in love with Meteor

This post from the Meteor Forums is drawing some attention. (Thanks to HashBang Weekly for the link.)

Sat, 08 Jul 2017

'Learn Ruby on Rails' by Daniel Kehoe updated for Rails 5.1

'Learn Ruby on Rails' by Daniel Kehoe has been updated for Rails 5.1.

Sun, 02 Jul 2017

7 Strengths of #ReactJS Every Programmer Should Know About

https://blog.reactiveconf.com/7-strengths-of-reactjs-every-programmer-should-know-about-6a5f3a69a861

Sun, 18 Jun 2017

Eloquent Javascript, Chapter 3 (Functions) -- what the hell?

I read Chapter 3 of Eloquent Javascript some time ago, and it's a difficult one. It introduces the concept of functions. Quickly introduced are: Parameters and Scopes, Nested Scopes, Closure and Recursion.

It is too much, too fast with too few examples. I was able to do the first exercise, Minimum, but got lost in the second, Recursion.

Here is my solution for Minimum:

#!/usr/bin/env node
/* Eloquent Javascript, Chapter 3, Page 56, Exercises 
Create a function to find the minimum of two arguments

By Steven Rosenberg, 6/17/2017 */

function smallest(first_number, second_number) {
    if (first_number < second_number)
        return first_number;
    else if (second_number < first_number)
        return second_number;
    else
        console.log("They are equal")
}

// Output will be the smallest of these two numbers
console.log(smallest(100, 2));

Expressing this as a function doesn't really do much. The program could just as easily have been written in a straight "procedural" format. But it's a function, and it works.

The second problem on recursion stumped me. I'm pretty sure I can figure it out, but I need more time to think (and look up more on recursion).